diff --git a/docs/examples/ts/aave_bridge/index.ts b/docs/examples/ts/aave_bridge/index.ts index 07e3a94eaca7..db53401fcc00 100644 --- a/docs/examples/ts/aave_bridge/index.ts +++ b/docs/examples/ts/aave_bridge/index.ts @@ -351,6 +351,8 @@ const INBOX_ABI = [ { name: "index", type: "uint256", indexed: false }, { name: "hash", type: "bytes32", indexed: true }, { name: "rollingHash", type: "bytes16", indexed: false }, + { name: "inboxRollingHash", type: "bytes32", indexed: false }, + { name: "bucketSeq", type: "uint256", indexed: false }, ], }, ] as const; diff --git a/docs/examples/ts/example_swap/index.ts b/docs/examples/ts/example_swap/index.ts index 9c367a82b0c5..099c8cea3878 100644 --- a/docs/examples/ts/example_swap/index.ts +++ b/docs/examples/ts/example_swap/index.ts @@ -263,6 +263,8 @@ const INBOX_ABI = [ { name: "index", type: "uint256", indexed: false }, { name: "hash", type: "bytes32", indexed: true }, { name: "rollingHash", type: "bytes16", indexed: false }, + { name: "inboxRollingHash", type: "bytes32", indexed: false }, + { name: "bucketSeq", type: "uint256", indexed: false }, ], }, ] as const; diff --git a/docs/examples/ts/token_bridge/index.ts b/docs/examples/ts/token_bridge/index.ts index 18f3508ac046..02f8976bf7e7 100644 --- a/docs/examples/ts/token_bridge/index.ts +++ b/docs/examples/ts/token_bridge/index.ts @@ -169,6 +169,8 @@ const INBOX_ABI = [ { name: "index", type: "uint256", indexed: false }, { name: "hash", type: "bytes32", indexed: true }, { name: "rollingHash", type: "bytes16", indexed: false }, + { name: "inboxRollingHash", type: "bytes32", indexed: false }, + { name: "bucketSeq", type: "uint256", indexed: false }, ], }, ] as const; diff --git a/l1-contracts/src/core/RollupCore.sol b/l1-contracts/src/core/RollupCore.sol index 73b3da4c4b41..cc66c96895e2 100644 --- a/l1-contracts/src/core/RollupCore.sol +++ b/l1-contracts/src/core/RollupCore.sol @@ -27,7 +27,7 @@ import {ProposeArgs} from "@aztec/core/libraries/rollup/ProposeLib.sol"; import {STFLib, GenesisState} from "@aztec/core/libraries/rollup/STFLib.sol"; import {StakingLib} from "@aztec/core/libraries/rollup/StakingLib.sol"; import {Timestamp, Slot, Epoch, TimeLib} from "@aztec/core/libraries/TimeLib.sol"; -import {Inbox} from "@aztec/core/messagebridge/Inbox.sol"; +import {Inbox, INBOX_BUCKET_RING_SIZE} from "@aztec/core/messagebridge/Inbox.sol"; import {Outbox} from "@aztec/core/messagebridge/Outbox.sol"; import {ISlasher} from "@aztec/core/slashing/Slasher.sol"; import {GSE} from "@aztec/governance/GSE.sol"; @@ -621,7 +621,14 @@ contract RollupCore is EIP712("Aztec Rollup", "1"), Ownable, IStakingCore, IVali IInbox inbox = IInbox( address( - new Inbox(address(this), _feeAsset, _config.version, Constants.L1_TO_L2_MSG_SUBTREE_HEIGHT, _config.inboxLag) + new Inbox( + address(this), + _feeAsset, + _config.version, + Constants.L1_TO_L2_MSG_SUBTREE_HEIGHT, + _config.inboxLag, + INBOX_BUCKET_RING_SIZE + ) ) ); diff --git a/l1-contracts/src/core/interfaces/IRollup.sol b/l1-contracts/src/core/interfaces/IRollup.sol index 19f24b72fdb4..6a347b11d8d5 100644 --- a/l1-contracts/src/core/interfaces/IRollup.sol +++ b/l1-contracts/src/core/interfaces/IRollup.sol @@ -27,6 +27,11 @@ struct PublicInputArgs { bytes32 previousArchive; bytes32 endArchive; bytes32 outHash; + // Inbox rolling-hash chain segment consumed across the proven epoch (AZIP-22 Fast Inbox). Deliberately UNVALIDATED + // until the Fast Inbox flip, when they get checked against per-checkpoint records written at propose; for now they + // are only passed through to the proof's public inputs. + bytes32 previousInboxRollingHash; + bytes32 endInboxRollingHash; address proverId; } diff --git a/l1-contracts/src/core/interfaces/messagebridge/IInbox.sol b/l1-contracts/src/core/interfaces/messagebridge/IInbox.sol index a001403791da..8a9366b1b0c5 100644 --- a/l1-contracts/src/core/interfaces/messagebridge/IInbox.sol +++ b/l1-contracts/src/core/interfaces/messagebridge/IInbox.sol @@ -4,6 +4,11 @@ pragma solidity >=0.8.27; import {DataStructures} from "../../libraries/DataStructures.sol"; +// Maximum number of messages a single bucket can hold before further messages in the same L1 block spill over +// into the next bucket. Matches the number of L1 to L2 messages a single L2 block can insert once the streaming +// inbox is live, so any one bucket is always consumable by one block. +uint256 constant MAX_MSGS_PER_BUCKET = 256; + /** * @title Inbox * @author Aztec Labs @@ -13,6 +18,8 @@ interface IInbox { struct InboxState { // Rolling hash of all messages inserted into the inbox. // Used by clients to check for consistency. + // TODO: remove once the streaming inbox (AZIP-22 Fast Inbox) flips on and clients rely on the + // consensus rolling hash tracked in the buckets instead. bytes16 rollingHash; // This value is not used much by the contract, but it is useful for synching the node faster // as it can more easily figure out if it can just skip looking for events for a time period. @@ -21,14 +28,43 @@ interface IInbox { uint64 inProgress; } + /** + * @notice Snapshot of the consensus rolling hash over the messages inserted into the Inbox, stored in a + * fixed-size ring indexed by a dense bucket sequence number (`seq % ringSize`). A bucket only accumulates + * messages sent within a single L1 block, so its final state is the chain position as of the end of that + * block; the censorship check at `propose` compares the checkpoint header's rolling hash against these + * snapshots. + */ + struct InboxBucket { + // Rolling hash after the last message absorbed into this bucket. Each link is + // `sha256ToField(previousRollingHash || leaf)`; the genesis value is zero. + bytes32 rollingHash; + // Cumulative number of messages inserted into the Inbox up to and including this bucket. + uint64 totalMsgCount; + // L1 block timestamp at which this bucket was opened. Recency comparisons (message lag, + // censorship cutoff) are done in seconds against this value. + uint64 timestamp; + // Number of messages absorbed into this bucket, capped at the per-bucket maximum. + uint32 msgCount; + } + /** * @notice Emitted when a message is sent * @param checkpointNumber - The checkpoint number in which the message is included * @param index - The index of the message in the L1 to L2 messages tree * @param hash - The hash of the message * @param rollingHash - The rolling hash of all messages inserted into the inbox + * @param inboxRollingHash - The consensus rolling hash (truncated sha256 chain) after this message + * @param bucketSeq - The sequence number of the bucket this message was absorbed into */ - event MessageSent(uint256 indexed checkpointNumber, uint256 index, bytes32 indexed hash, bytes16 rollingHash); + event MessageSent( + uint256 indexed checkpointNumber, + uint256 index, + bytes32 indexed hash, + bytes16 rollingHash, + bytes32 inboxRollingHash, + uint256 bucketSeq + ); // docs:start:send_l1_to_l2_message /** @@ -68,4 +104,18 @@ interface IInbox { function getTotalMessagesInserted() external view returns (uint64); function getInProgress() external view returns (uint64); + + /** + * @notice Returns the sequence number of the bucket currently accumulating messages + * @return The current bucket sequence number + */ + function getCurrentBucketSeq() external view returns (uint64); + + /** + * @notice Returns the bucket with the given sequence number + * @dev Reverts if the bucket is ahead of the current one or has already been overwritten in the ring + * @param _seq - The bucket sequence number + * @return The bucket + */ + function getBucket(uint256 _seq) external view returns (InboxBucket memory); } diff --git a/l1-contracts/src/core/libraries/Errors.sol b/l1-contracts/src/core/libraries/Errors.sol index 01152320a831..db0ea9ed37bd 100644 --- a/l1-contracts/src/core/libraries/Errors.sol +++ b/l1-contracts/src/core/libraries/Errors.sol @@ -28,6 +28,7 @@ library Errors { error Inbox__ContentTooLarge(bytes32 content); // 0x47452014 error Inbox__SecretHashTooLarge(bytes32 secretHash); // 0xecde7e2c error Inbox__MustBuildBeforeConsume(); // 0xc4901999 + error Inbox__BucketOutOfWindow(uint256 seq, uint256 current); // 0xfee255b7 // Outbox error Outbox__Unauthorized(); // 0x2c9490c2 @@ -58,6 +59,11 @@ library Errors { error Rollup__InvalidCheckpointHeaderCount(uint256 expected, uint256 actual); error Rollup__InvalidCheckpointNumber(uint256 expected, uint256 actual); // 0xd1ba9bfa error Rollup__InvalidInHash(bytes32 expected, bytes32 actual); // 0xcd6f4233 + error Rollup__InvalidInboxRollingHash(bytes32 expected, bytes32 actual); // 0xed1f7bb5 + error Rollup__InboxBucketStillMutable(uint256 bucketSeq); // 0x7254b980 + error Rollup__UnconsumedInboxMessages(uint256 nextBucketSeq); // 0x2bd4bf10 + error Rollup__InboxConsumptionBehindParent(uint256 expected, uint256 actual); // 0x54e0c025 + error Rollup__TooManyInboxMessagesConsumed(uint256 consumed); // 0xf76d1426 error Rollup__InvalidOutHash(bytes32 expected, bytes32 actual); // 0x8eb39062 error Rollup__InvalidPreviousArchive(bytes32 expected, bytes32 actual); // 0xb682a40e error Rollup__InvalidProof(); // 0xa5b2ba17 diff --git a/l1-contracts/src/core/libraries/crypto/Hash.sol b/l1-contracts/src/core/libraries/crypto/Hash.sol index b2d4df0aac56..18fc73e180b3 100644 --- a/l1-contracts/src/core/libraries/crypto/Hash.sol +++ b/l1-contracts/src/core/libraries/crypto/Hash.sol @@ -49,4 +49,16 @@ library Hash { function sha256ToField(bytes memory _data) internal pure returns (bytes32) { return bytes32(bytes.concat(new bytes(1), bytes31(sha256(_data)))); } + + /** + * @notice Advances the Inbox consensus rolling hash by one message leaf + * @dev Truncated at every link so the value is always a field element; the rollup circuits recompute the + * identical chain over the message leaves they insert. The genesis value is zero. + * @param _rollingHash - The current rolling hash + * @param _leaf - The message leaf to absorb + * @return The updated rolling hash + */ + function accumulateInboxRollingHash(bytes32 _rollingHash, bytes32 _leaf) internal pure returns (bytes32) { + return sha256ToField(abi.encodePacked(_rollingHash, _leaf)); + } } diff --git a/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol b/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol index 85284b38fa97..06aa075932cf 100644 --- a/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol +++ b/l1-contracts/src/core/libraries/rollup/EpochProofLib.sol @@ -109,6 +109,8 @@ library EpochProofLib { Epoch endEpoch = assertAcceptable(_args.start, _args.end); + // Rehash the supplied headers against storage once, here: the public-input assembly below reads the fee + // recipient/value out of them and relies on this call having run. verifyHeaders(_args.start, _args.end, _args.headers); // Verify attestations for the last checkpoint in the epoch @@ -150,6 +152,11 @@ library EpochProofLib { * own public inputs used for generating the proof vs the ones assembled * by this contract when verifying it. * + * @dev The fee recipient/value public inputs are sourced from the supplied headers, so this entry point rehashes + * them against storage before assembling: an off-chain caller must not walk away with public inputs built from + * unverified fee fields and only discover the mismatch when the on-chain proof reverts. The submit path verifies + * the headers up front and assembles via computeEpochProofPublicInputs to avoid rehashing them twice. + * * @param _start - The start of the epoch (inclusive) * @param _end - The end of the epoch (inclusive) * @param _args - Array of public inputs to the proof (previousArchive, endArchive, endTimestamp, outHash, proverId) @@ -163,6 +170,107 @@ library EpochProofLib { ProposedHeader[] calldata _headers, bytes calldata _blobPublicInputs ) internal view returns (bytes32[] memory) { + verifyHeaders(_start, _end, _headers); + return computeEpochProofPublicInputs(_start, _end, _args, _headers, _blobPublicInputs); + } + + /** + * @notice Verifies committee attestations for the last checkpoint in the epoch before accepting the epoch proof + * + * @dev This verification ensures that the committee has properly validated the final state of the epoch + * before the proof can be accepted. The function validates that: + * 1. The provided attestations match the stored attestation hash for the checkpoint + * 2. The attestations have valid signatures from committee members + * 3. The attestations meet the required threshold (2/3+ of committee) + * + * For escape hatch epochs, attestation verification is skipped since there is no committee + * involvement - only the designated escape hatch proposer can propose blocks. + * + * @dev Errors Thrown: + * - Rollup__InvalidAttestations: Provided attestations don't match stored hash or fail validation + * + * @param _endCheckpointNumber The last checkpoint number in the epoch to verify attestations for + * @param _attestations The committee attestations containing signatures and validator information + */ + function verifyLastCheckpointAttestationsAndOutHash( + uint256 _endCheckpointNumber, + CommitteeAttestations memory _attestations, + bytes32 _outHash + ) private { + // Get the stored attestation hash and payload digest for the last checkpoint + CompressedTempCheckpointLog storage checkpointLog = STFLib.getStorageTempCheckpointLog(_endCheckpointNumber); + + // Verify that the out hash matches the stored value + // The stored out hash is part of the payloadDigest that was attested to. + require(checkpointLog.outHash == _outHash, Errors.Rollup__InvalidOutHash(checkpointLog.outHash, _outHash)); + + // Verify that the provided attestations match the stored hash + bytes32 providedAttestationsHash = keccak256(abi.encode(_attestations)); + require(providedAttestationsHash == checkpointLog.attestationsHash, Errors.Rollup__InvalidAttestations()); + + // Get the epoch for the last checkpoint + Epoch epoch = STFLib.getEpochForCheckpoint(_endCheckpointNumber); + + // Check if this is an escape hatch epoch - skip attestation verification if so + // since escape hatch blocks are proposed without committee attestations. + // Uses epoch-stable lookup so proof verification uses the escape hatch that was + // active when the epoch started, not whatever is currently configured. + { + IEscapeHatch escapeHatch = ValidatorSelectionLib.getEscapeHatchForEpoch(epoch); + if (address(escapeHatch) != address(0)) { + (bool isOpen,) = escapeHatch.isHatchOpen(epoch); + if (isOpen) { + // Skip attestation verification for escape hatch epochs + return; + } + } + } + + ValidatorSelectionLib.verifyAttestations(epoch, _attestations, checkpointLog.payloadDigest); + } + + /** + * @notice Rehashes each provided checkpoint header and requires it to match the stored header hash + * + * @param _start The first checkpoint number in the epoch (inclusive) + * @param _end The last checkpoint number in the epoch (inclusive) + * @param _headers The proposed headers for each checkpoint in [_start, _end] + */ + function verifyHeaders(uint256 _start, uint256 _end, ProposedHeader[] calldata _headers) private view { + uint256 numCheckpoints = _end - _start + 1; + require( + _headers.length == numCheckpoints, Errors.Rollup__InvalidCheckpointHeaderCount(numCheckpoints, _headers.length) + ); + + for (uint256 i = 0; i < numCheckpoints; i++) { + bytes32 expectedHeaderHash = STFLib.getHeaderHash(_start + i); + bytes32 providedHeaderHash = ProposedHeaderLib.hash(_headers[i]); + require( + providedHeaderHash == expectedHeaderHash, + Errors.Rollup__InvalidCheckpointHeader(expectedHeaderHash, providedHeaderHash) + ); + } + } + + /** + * @notice Assembles the root rollup public inputs, taking the supplied checkpoint headers as already verified + * + * @dev Callers must have rehashed `_headers` against the stored header hashes beforehand, since the fee + * recipient/value public inputs are read straight out of them. + * + * @param _start - The start of the epoch (inclusive) + * @param _end - The end of the epoch (inclusive) + * @param _args - Array of public inputs to the proof (previousArchive, endArchive, endTimestamp, outHash, proverId) + * @param _headers - The proposed checkpoint headers supplying the fee recipient and value for each checkpoint + * @param _blobPublicInputs- The blob public inputs for the proof + */ + function computeEpochProofPublicInputs( + uint256 _start, + uint256 _end, + PublicInputArgs calldata _args, + ProposedHeader[] calldata _headers, + bytes calldata _blobPublicInputs + ) private view returns (bytes32[] memory) { RollupStore storage rollupStore = STFLib.getStorage(); { @@ -191,6 +299,8 @@ library EpochProofLib { // previous_archive_root: Field, // end_archive_root: Field, // out_hash: Field, + // previous_inbox_rolling_hash: Field, + // end_inbox_rolling_hash: Field, // checkpointHeaderHashes: [Field; Constants.MAX_CHECKPOINTS_PER_EPOCH], // fees: [FeeRecipient; Constants.MAX_CHECKPOINTS_PER_EPOCH], // chain_id: Field, @@ -208,15 +318,21 @@ library EpochProofLib { publicInputs[1] = _args.endArchive; publicInputs[2] = _args.outHash; + + // Inbox rolling-hash chain segment consumed across the epoch (AZIP-22 Fast Inbox). Deliberately UNVALIDATED + // until the Fast Inbox flip, when they get checked against per-checkpoint records written at propose; for now + // they are only passed through to the proof's public inputs. + publicInputs[3] = _args.previousInboxRollingHash; + publicInputs[4] = _args.endInboxRollingHash; } uint256 numCheckpoints = _end - _start + 1; for (uint256 i = 0; i < numCheckpoints; i++) { - publicInputs[3 + i] = STFLib.getHeaderHash(_start + i); + publicInputs[5 + i] = STFLib.getHeaderHash(_start + i); } - uint256 offset = 3 + Constants.MAX_CHECKPOINTS_PER_EPOCH; + uint256 offset = 5 + Constants.MAX_CHECKPOINTS_PER_EPOCH; // Taking recipient/value from the checkpoint headers rather than the prover // as defense in depth. Slots past numCheckpoints stay zero. @@ -276,84 +392,6 @@ library EpochProofLib { return publicInputs; } - /** - * @notice Verifies committee attestations for the last checkpoint in the epoch before accepting the epoch proof - * - * @dev This verification ensures that the committee has properly validated the final state of the epoch - * before the proof can be accepted. The function validates that: - * 1. The provided attestations match the stored attestation hash for the checkpoint - * 2. The attestations have valid signatures from committee members - * 3. The attestations meet the required threshold (2/3+ of committee) - * - * For escape hatch epochs, attestation verification is skipped since there is no committee - * involvement - only the designated escape hatch proposer can propose blocks. - * - * @dev Errors Thrown: - * - Rollup__InvalidAttestations: Provided attestations don't match stored hash or fail validation - * - * @param _endCheckpointNumber The last checkpoint number in the epoch to verify attestations for - * @param _attestations The committee attestations containing signatures and validator information - */ - function verifyLastCheckpointAttestationsAndOutHash( - uint256 _endCheckpointNumber, - CommitteeAttestations memory _attestations, - bytes32 _outHash - ) private { - // Get the stored attestation hash and payload digest for the last checkpoint - CompressedTempCheckpointLog storage checkpointLog = STFLib.getStorageTempCheckpointLog(_endCheckpointNumber); - - // Verify that the out hash matches the stored value - // The stored out hash is part of the payloadDigest that was attested to. - require(checkpointLog.outHash == _outHash, Errors.Rollup__InvalidOutHash(checkpointLog.outHash, _outHash)); - - // Verify that the provided attestations match the stored hash - bytes32 providedAttestationsHash = keccak256(abi.encode(_attestations)); - require(providedAttestationsHash == checkpointLog.attestationsHash, Errors.Rollup__InvalidAttestations()); - - // Get the epoch for the last checkpoint - Epoch epoch = STFLib.getEpochForCheckpoint(_endCheckpointNumber); - - // Check if this is an escape hatch epoch - skip attestation verification if so - // since escape hatch blocks are proposed without committee attestations. - // Uses epoch-stable lookup so proof verification uses the escape hatch that was - // active when the epoch started, not whatever is currently configured. - { - IEscapeHatch escapeHatch = ValidatorSelectionLib.getEscapeHatchForEpoch(epoch); - if (address(escapeHatch) != address(0)) { - (bool isOpen,) = escapeHatch.isHatchOpen(epoch); - if (isOpen) { - // Skip attestation verification for escape hatch epochs - return; - } - } - } - - ValidatorSelectionLib.verifyAttestations(epoch, _attestations, checkpointLog.payloadDigest); - } - - /** - * @notice Rehashes each provided checkpoint header and requires it to match the stored header hash - * - * @param _start The first checkpoint number in the epoch (inclusive) - * @param _end The last checkpoint number in the epoch (inclusive) - * @param _headers The proposed headers for each checkpoint in [_start, _end] - */ - function verifyHeaders(uint256 _start, uint256 _end, ProposedHeader[] calldata _headers) private view { - uint256 numCheckpoints = _end - _start + 1; - require( - _headers.length == numCheckpoints, Errors.Rollup__InvalidCheckpointHeaderCount(numCheckpoints, _headers.length) - ); - - for (uint256 i = 0; i < numCheckpoints; i++) { - bytes32 expectedHeaderHash = STFLib.getHeaderHash(_start + i); - bytes32 providedHeaderHash = ProposedHeaderLib.hash(_headers[i]); - require( - providedHeaderHash == expectedHeaderHash, - Errors.Rollup__InvalidCheckpointHeader(expectedHeaderHash, providedHeaderHash) - ); - } - } - /** * @notice Validates that an epoch proof submission meets all acceptance criteria * @@ -421,6 +459,9 @@ library EpochProofLib { * 2. Assembling the public inputs for the root rollup circuit * 3. Verifying the validity proof against the assembled public inputs using the configured verifier * + * @dev Assumes the caller has already verified the supplied checkpoint headers against storage, so assembly skips + * rehashing them. + * * @dev Errors Thrown: * - Rollup__InvalidBlobProof: Batched blob proof verification failed * - Rollup__InvalidProof: validity proof verification failed @@ -436,7 +477,7 @@ library EpochProofLib { BlobLib.validateBatchedBlob(_args.blobInputs); bytes32[] memory publicInputs = - getEpochProofPublicInputs(_args.start, _args.end, _args.args, _args.headers, _args.blobInputs); + computeEpochProofPublicInputs(_args.start, _args.end, _args.args, _args.headers, _args.blobInputs); require(rollupStore.config.epochProofVerifier.verify(_args.proof, publicInputs), Errors.Rollup__InvalidProof()); diff --git a/l1-contracts/src/core/libraries/rollup/ProposeLib.sol b/l1-contracts/src/core/libraries/rollup/ProposeLib.sol index e4807e5bcc71..8b4022175636 100644 --- a/l1-contracts/src/core/libraries/rollup/ProposeLib.sol +++ b/l1-contracts/src/core/libraries/rollup/ProposeLib.sol @@ -5,6 +5,7 @@ pragma solidity >=0.8.27; import {BlobLib} from "@aztec-blob-lib/BlobLib.sol"; import {IEscapeHatch} from "@aztec/core/interfaces/IEscapeHatch.sol"; import {RollupStore, IRollupCore, CheckpointHeaderValidationFlags} from "@aztec/core/interfaces/IRollup.sol"; +import {IInbox, MAX_MSGS_PER_BUCKET} from "@aztec/core/interfaces/messagebridge/IInbox.sol"; import {TempCheckpointLog} from "@aztec/core/libraries/compressed-data/CheckpointLog.sol"; import {FeeHeader} from "@aztec/core/libraries/compressed-data/fees/FeeStructs.sol"; import {ChainTipsLib, CompressedChainTips} from "@aztec/core/libraries/compressed-data/Tips.sol"; @@ -20,6 +21,14 @@ import {Signature} from "@aztec/shared/libraries/SignatureLib.sol"; import {ProposedHeader, ProposedHeaderLib} from "./ProposedHeaderLib.sol"; import {STFLib} from "./STFLib.sol"; +// Streaming-inbox protocol constants (AZIP-22 Fast Inbox). These mirror the protocol circuit constants and +// should move into the generated Constants library once the Solidity emitter includes them. +// Minimum bucket age, in seconds, at the start of a checkpoint's build frame for its consumption to be +// mandatory. One L1 slot: validators cannot be required to act on buckets they may not have seen. +uint256 constant INBOX_LAG_SECONDS = 12; +// Maximum number of L1 to L2 messages a single checkpoint can insert. +uint256 constant MAX_L1_TO_L2_MSGS_PER_CHECKPOINT = 1024; + struct ProposeArgs { bytes32 archive; OracleInput oracleInput; @@ -370,6 +379,91 @@ library ProposeLib { ); } + /** + * @notice Validates a checkpoint's Inbox consumption against the streaming inbox buckets and returns how + * far consumption has reached. Not yet called from propose(): the legacy `consume()`/`inHash` flow + * remains the enforced path until the streaming inbox (AZIP-22 Fast Inbox) flips on. + * + * @dev Read-only; performs no Inbox write. Checks, in order: + * 1. The checkpoint header's `inboxRollingHash` must equal the rolling hash snapshotted in the Inbox + * bucket referenced by `_bucketHint`. The hint is a plain calldata lookup aid, not signed and not + * part of the header: a wrong hint cannot change what gets accepted, it only reverts. A checkpoint + * that consumes no messages references the same bucket as its parent. + * 2. The referenced bucket must be settled: a bucket that can still absorb another message is not a + * snapshot of anything. + * 3. Consumption moves forward: the referenced bucket's cumulative total must be at least the parent + * checkpoint's (equal consumes nothing; behind is a hard revert). This precedes the subtractions + * below, which rely on `bucket.totalMsgCount >= _parentTotalMsgCount` to not underflow. + * 4. Cap upper bound: a single checkpoint cannot consume more than MAX_L1_TO_L2_MSGS_PER_CHECKPOINT + * messages, the maximum the circuits can insert. + * 5. Mandatory consumption (the censorship assert): the first unconsumed bucket (`_bucketHint + 1`) + * must either not exist, sit past the consumption cutoff, or be cap-escaped — consuming through it + * would exceed MAX_L1_TO_L2_MSGS_PER_CHECKPOINT messages since the parent checkpoint's cumulative + * total. The cutoff is the start of the checkpoint's build frame minus INBOX_LAG_SECONDS: a + * checkpoint proposed in slot S is built during slot S-1, and validators are not required to have + * seen buckets younger than one L1 slot at build start. + * + * No consumed-bucket pointer is written here. The caller (FI-14) stores the returned consumed + * position in the checkpoint's temp-log record, which is the authoritative consumed total: temp logs + * rewind with the pending chain on a prune, so the record stays prune-consistent — unlike an + * Inbox-side pointer advanced with the pending chain, which would sit ahead of the replacement chain. + * + * @param _inbox - The Inbox holding the rolling-hash buckets + * @param _inboxRollingHash - The checkpoint header's inbox rolling hash + * @param _bucketHint - Sequence number of the bucket the header's rolling hash corresponds to + * @param _slotNumber - The slot the checkpoint is proposed in + * @param _parentTotalMsgCount - Cumulative Inbox message count consumed as of the parent checkpoint + * @return The cumulative Inbox message count consumed as of this checkpoint (`bucket.totalMsgCount`), for + * the caller to store in the checkpoint's temp-log record + */ + function validateInboxConsumption( + IInbox _inbox, + bytes32 _inboxRollingHash, + uint256 _bucketHint, + Slot _slotNumber, + uint256 _parentTotalMsgCount + ) internal view returns (uint256) { + IInbox.InboxBucket memory bucket = _inbox.getBucket(_bucketHint); + require( + bucket.rollingHash == _inboxRollingHash, + Errors.Rollup__InvalidInboxRollingHash(bucket.rollingHash, _inboxRollingHash) + ); + + // A bucket that can still absorb a message mutates in place: a proposer bundling a send after its own propose + // in one L1 transaction would leave the checkpoint committed to a rolling hash that exists neither on L1 nor + // in any node, which only ever observes a bucket's end-of-block state, and no honest node could then resolve + // the consumed position. Settled is the negation of the Inbox's rollover condition: the genesis bucket never + // absorbs, a bucket whose L1 block has passed cannot be reopened, and a full bucket spills the next message + // into a new one. + require( + _bucketHint == 0 || bucket.timestamp < block.timestamp || bucket.msgCount == MAX_MSGS_PER_BUCKET, + Errors.Rollup__InboxBucketStillMutable(_bucketHint) + ); + + require( + bucket.totalMsgCount >= _parentTotalMsgCount, + Errors.Rollup__InboxConsumptionBehindParent(_parentTotalMsgCount, bucket.totalMsgCount) + ); + + require( + bucket.totalMsgCount - _parentTotalMsgCount <= MAX_L1_TO_L2_MSGS_PER_CHECKPOINT, + Errors.Rollup__TooManyInboxMessagesConsumed(bucket.totalMsgCount - _parentTotalMsgCount) + ); + + if (_bucketHint < _inbox.getCurrentBucketSeq()) { + IInbox.InboxBucket memory next = _inbox.getBucket(_bucketHint + 1); + Timestamp buildFrameStart = TimeLib.toTimestamp(_slotNumber - Slot.wrap(1)); + Timestamp cutoff = buildFrameStart - Timestamp.wrap(INBOX_LAG_SECONDS); + require( + next.timestamp > Timestamp.unwrap(cutoff) + || next.totalMsgCount - _parentTotalMsgCount > MAX_L1_TO_L2_MSGS_PER_CHECKPOINT, + Errors.Rollup__UnconsumedInboxMessages(_bucketHint + 1) + ); + } + + return bucket.totalMsgCount; + } + /** * @notice Gets the mana min fee components * For more context, consult: diff --git a/l1-contracts/src/core/libraries/rollup/ProposedHeaderLib.sol b/l1-contracts/src/core/libraries/rollup/ProposedHeaderLib.sol index d60e1edd6056..5a456dda77bb 100644 --- a/l1-contracts/src/core/libraries/rollup/ProposedHeaderLib.sol +++ b/l1-contracts/src/core/libraries/rollup/ProposedHeaderLib.sol @@ -22,6 +22,7 @@ struct ProposedHeader { bytes32 blockHeadersHash; bytes32 blobsHash; bytes32 inHash; + bytes32 inboxRollingHash; bytes32 outHash; Slot slotNumber; Timestamp timestamp; @@ -56,6 +57,7 @@ library ProposedHeaderLib { _header.blockHeadersHash, _header.blobsHash, _header.inHash, + _header.inboxRollingHash, _header.outHash, _header.slotNumber, Timestamp.unwrap(_header.timestamp).toUint64(), diff --git a/l1-contracts/src/core/messagebridge/Inbox.sol b/l1-contracts/src/core/messagebridge/Inbox.sol index 8355421b6178..c0782bc87909 100644 --- a/l1-contracts/src/core/messagebridge/Inbox.sol +++ b/l1-contracts/src/core/messagebridge/Inbox.sol @@ -3,7 +3,7 @@ pragma solidity >=0.8.27; import {IRollup} from "@aztec/core/interfaces/IRollup.sol"; -import {IInbox} from "@aztec/core/interfaces/messagebridge/IInbox.sol"; +import {IInbox, MAX_MSGS_PER_BUCKET} from "@aztec/core/interfaces/messagebridge/IInbox.sol"; import {Constants} from "@aztec/core/libraries/ConstantsGen.sol"; import {FrontierLib} from "@aztec/core/libraries/crypto/FrontierLib.sol"; import {Hash} from "@aztec/core/libraries/crypto/Hash.sol"; @@ -13,6 +13,17 @@ import {FeeJuicePortal} from "@aztec/core/messagebridge/FeeJuicePortal.sol"; import {IERC20} from "@oz/token/ERC20/IERC20.sol"; import {SafeCast} from "@oz/utils/math/SafeCast.sol"; +// Number of buckets in the rolling-hash ring. Sized far beyond normal consumption lag (the censorship +// cutoff bounds it to roughly one build frame); outages longer than the ring are handled by overwrite +// protection on unconsumed buckets, not by growing the ring. +uint256 constant INBOX_BUCKET_RING_SIZE = 1024; + +// Constructor floor for the bucket ring. The ring must cover the longest stall the chain recovers from on +// its own: the prune-and-repropose window of 64 checkpoints (2 epochs = 384 L1 blocks) at the natural cadence +// of one bucket per L1 block, so the buckets it must re-consume after a prune have not been overwritten. 384 +// rounded up to the next power of two, kept at or below the production ring. +uint256 constant MIN_BUCKET_RING_SIZE = 512; + /** * @title Inbox * @author Aztec Labs @@ -29,6 +40,8 @@ contract Inbox is IInbox { uint256 public immutable LAG; + uint256 public immutable BUCKET_RING_SIZE; + uint256 internal immutable HEIGHT; uint256 internal immutable SIZE; bytes32 internal immutable EMPTY_ROOT; // The root of an empty frontier tree @@ -40,7 +53,20 @@ contract Inbox is IInbox { InboxState internal state; - constructor(address _rollup, IERC20 _feeAsset, uint256 _version, uint256 _height, uint256 _lag) { + // Ring of rolling-hash buckets, keyed by `bucketSeq % BUCKET_RING_SIZE`. Inert for the legacy + // frontier-tree flow; consumed by the streaming inbox checks at `propose` (AZIP-22 Fast Inbox). + mapping(uint256 ringIndex => InboxBucket bucket) internal buckets; + + uint64 internal currentBucketSeq; + + constructor( + address _rollup, + IERC20 _feeAsset, + uint256 _version, + uint256 _height, + uint256 _lag, + uint256 _bucketRingSize + ) { ROLLUP = _rollup; VERSION = _version; @@ -50,10 +76,18 @@ contract Inbox is IInbox { require(_lag > 0, "LAG TOO SMALL"); LAG = _lag; + require(_bucketRingSize >= MIN_BUCKET_RING_SIZE, "BUCKET RING TOO SMALL"); + BUCKET_RING_SIZE = _bucketRingSize; + state = InboxState({ rollingHash: 0, totalMessagesInserted: 0, inProgress: SafeCast.toUint64(Constants.INITIAL_CHECKPOINT_NUMBER + LAG) }); + // Genesis bucket: a checkpoint consuming no messages references the same bucket as its parent, so the + // first checkpoint against an empty Inbox references this one and no base case leaks into `propose`. + buckets[0] = + InboxBucket({rollingHash: 0, totalMsgCount: 0, timestamp: SafeCast.toUint64(block.timestamp), msgCount: 0}); + forest.initialize(_height); EMPTY_ROOT = trees[type(uint256).max].root(forest, HEIGHT, SIZE); @@ -122,7 +156,9 @@ contract Inbox is IInbox { rollingHash: updatedRollingHash, totalMessagesInserted: totalMessagesInserted + 1, inProgress: inProgress }); - emit MessageSent(inProgress, index, leaf, updatedRollingHash); + (uint64 bucketSeq, bytes32 inboxRollingHash) = _absorbIntoBucket(leaf); + + emit MessageSent(inProgress, index, leaf, updatedRollingHash, inboxRollingHash, bucketSeq); return (leaf, index); } @@ -177,4 +213,55 @@ contract Inbox is IInbox { function getInProgress() external view override(IInbox) returns (uint64) { return state.inProgress; } + + function getCurrentBucketSeq() external view override(IInbox) returns (uint64) { + return currentBucketSeq; + } + + function getBucket(uint256 _seq) external view override(IInbox) returns (InboxBucket memory) { + uint256 current = currentBucketSeq; + require(_seq <= current && current - _seq < BUCKET_RING_SIZE, Errors.Inbox__BucketOutOfWindow(_seq, current)); + return buckets[_seq % BUCKET_RING_SIZE]; + } + + /** + * @notice Absorbs a message leaf into the consensus rolling hash and snapshots it into the bucket ring + * + * @dev A bucket only holds messages from a single L1 block, up to MAX_MSGS_PER_BUCKET; the first message + * of a new L1 block — or the message after a full bucket, spilling over within the same block — opens the + * next bucket, inheriting the rolling hash and cumulative count. Bucket 0 is the pristine genesis base + * case and never absorbs. Opening a bucket overwrites the ring entry from BUCKET_RING_SIZE buckets ago; + * protection against overwriting unconsumed buckets is not enforced yet. + * + * @param _leaf - The message leaf to absorb + * + * @return The sequence number of the bucket the leaf was absorbed into and the updated rolling hash + */ + function _absorbIntoBucket(bytes32 _leaf) internal returns (uint64, bytes32) { + uint64 bucketSeq = currentBucketSeq; + InboxBucket memory bucket = buckets[bucketSeq % BUCKET_RING_SIZE]; + + // Buckets are keyed by L1 block timestamp: a strictly larger timestamp opens a new bucket (a full bucket + // also rolls over within the same block). Post-merge Ethereum increases block.timestamp strictly per block, + // so messages from different L1 blocks always land in different buckets. Under anvil with manual mining two + // blocks can share a timestamp and therefore a bucket; this is harmless because the consumption cutoff is + // computed over timestamps, so co-timestamped blocks are indistinguishable to it. + if (bucketSeq == 0 || bucket.timestamp < block.timestamp || bucket.msgCount == MAX_MSGS_PER_BUCKET) { + bucketSeq += 1; + currentBucketSeq = bucketSeq; + bucket = InboxBucket({ + rollingHash: bucket.rollingHash, + totalMsgCount: bucket.totalMsgCount, + timestamp: SafeCast.toUint64(block.timestamp), + msgCount: 0 + }); + } + + bucket.rollingHash = Hash.accumulateInboxRollingHash(bucket.rollingHash, _leaf); + bucket.totalMsgCount += 1; + bucket.msgCount += 1; + buckets[bucketSeq % BUCKET_RING_SIZE] = bucket; + + return (bucketSeq, bucket.rollingHash); + } } diff --git a/l1-contracts/test/Inbox.t.sol b/l1-contracts/test/Inbox.t.sol index daac928af500..68cccd760645 100644 --- a/l1-contracts/test/Inbox.t.sol +++ b/l1-contracts/test/Inbox.t.sol @@ -30,7 +30,9 @@ contract InboxTest is Test { function setUp() public { address rollup = address(this); IERC20 feeAsset = new TestERC20("Fee Asset", "FA", address(this)); - inbox = new InboxHarness(rollup, feeAsset, version, HEIGHT, TestConstants.AZTEC_INBOX_LAG); + inbox = new InboxHarness( + rollup, feeAsset, version, HEIGHT, TestConstants.AZTEC_INBOX_LAG, TestConstants.AZTEC_INBOX_BUCKET_RING_SIZE + ); emptyTreeRoot = inbox.getEmptyRoot(); } @@ -96,9 +98,12 @@ contract InboxTest is Test { bytes32 leaf = message.sha256ToField(); bytes16 expectedRollingHash = bytes16(keccak256(abi.encodePacked(stateBefore.rollingHash, leaf))); + bytes32 expectedInboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), leaf); vm.expectEmit(true, true, true, true); // event we expect - emit IInbox.MessageSent(FIRST_REAL_TREE_NUM, globalLeafIndex, leaf, expectedRollingHash); + emit IInbox.MessageSent( + FIRST_REAL_TREE_NUM, globalLeafIndex, leaf, expectedRollingHash, expectedInboxRollingHash, 1 + ); // event we will get (bytes32 insertedLeaf, uint256 insertedIndex) = inbox.sendL2Message(message.recipient, message.content, message.secretHash); diff --git a/l1-contracts/test/InboxBuckets.t.sol b/l1-contracts/test/InboxBuckets.t.sol new file mode 100644 index 000000000000..574621bcad1b --- /dev/null +++ b/l1-contracts/test/InboxBuckets.t.sol @@ -0,0 +1,292 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright 2024 Aztec Labs. +pragma solidity >=0.8.27; + +import {Test} from "forge-std/Test.sol"; +import {TestERC20} from "src/mock/TestERC20.sol"; +import {IERC20} from "@oz/token/ERC20/IERC20.sol"; +import {IInbox, MAX_MSGS_PER_BUCKET} from "@aztec/core/interfaces/messagebridge/IInbox.sol"; +import {MIN_BUCKET_RING_SIZE} from "@aztec/core/messagebridge/Inbox.sol"; +import {InboxHarness} from "./harnesses/InboxHarness.sol"; +import {TestConstants} from "./harnesses/TestConstants.sol"; +import {Constants} from "@aztec/core/libraries/ConstantsGen.sol"; +import {Errors} from "@aztec/core/libraries/Errors.sol"; +import {Hash} from "@aztec/core/libraries/crypto/Hash.sol"; +import {DataStructures} from "@aztec/core/libraries/DataStructures.sol"; + +contract InboxBucketsTest is Test { + uint256 internal constant FIRST_REAL_TREE_NUM = Constants.INITIAL_CHECKPOINT_NUMBER + TestConstants.AZTEC_INBOX_LAG; + uint256 internal constant HEIGHT = 10; + + InboxHarness internal inbox; + uint256 internal version = 0; + bytes32 internal expectedRollingHash; + + function setUp() public { + inbox = _deployInbox(TestConstants.AZTEC_INBOX_BUCKET_RING_SIZE); + } + + function _deployInbox(uint256 _ringSize) internal returns (InboxHarness) { + IERC20 feeAsset = new TestERC20("Fee Asset", "FA", address(this)); + return new InboxHarness(address(this), feeAsset, version, HEIGHT, TestConstants.AZTEC_INBOX_LAG, _ringSize); + } + + function _send(InboxHarness _inbox, uint256 _salt) internal returns (bytes32) { + (bytes32 leaf,) = _inbox.sendL2Message( + DataStructures.L2Actor({actor: bytes32(uint256(0x1000 + _salt)), version: version}), + bytes32(uint256(0x2000 + _salt)), + bytes32(uint256(0x3000 + _salt)) + ); + expectedRollingHash = Hash.accumulateInboxRollingHash(expectedRollingHash, leaf); + return leaf; + } + + // Sends a message and returns the gas consumed by the external `sendL2Message` call. The + // recipient/content/secretHash are built before the measurement window so only the call is timed. The + // figure is warm execution gas including the CALL overhead; it excludes the 21k intrinsic tx cost, calldata + // gas, and the cold-access surcharge a standalone EOA transaction pays on its first touch of each slot. + function _measureSend(InboxHarness _inbox, uint256 _salt) internal returns (uint256 gasUsed) { + DataStructures.L2Actor memory recipient = + DataStructures.L2Actor({actor: bytes32(uint256(0x1000 + _salt)), version: version}); + bytes32 content = bytes32(uint256(0x2000 + _salt)); + bytes32 secretHash = bytes32(uint256(0x3000 + _salt)); + + uint256 gasBefore = gasleft(); + _inbox.sendL2Message(recipient, content, secretHash); + gasUsed = gasBefore - gasleft(); + } + + // Shared test vectors for the rolling-hash chain, pinned across the noir circuits, the TS mirror, + // and this L1 implementation. Generated from an independent sha256 implementation. + function testRollingHashTestVectors() public pure { + bytes32 h = Hash.accumulateInboxRollingHash(bytes32(0), bytes32(uint256(11))); + assertEq(h, 0x00815fb1e9d2076ae5761439b6144ad11da69eb6c41ab2aca39e770407ad8d12, "chain(0, [11])"); + + h = Hash.accumulateInboxRollingHash(h, bytes32(uint256(22))); + h = Hash.accumulateInboxRollingHash(h, bytes32(uint256(33))); + assertEq(h, 0x0014cae968461979aab6d33266a2310ed234d3f6cf4472737c57551db07bd0da, "chain(0, [11, 22, 33])"); + + h = bytes32(0); + for (uint256 i = 1; i <= 256; i++) { + h = Hash.accumulateInboxRollingHash(h, bytes32(i)); + } + assertEq(h, 0x00ea95b96f17b75be03525b35a2a1918b42f03ad8c00a437cf641751825f3992, "chain(0, [1..=256])"); + + h = Hash.accumulateInboxRollingHash(bytes32(uint256(0x2a)), bytes32(uint256(7))); + assertEq(h, 0x0032a934005556d1b9d22708666ee8b05f91fafad624dd64a6ea878e048e5438, "chain(0x2a, [7])"); + + h = Hash.accumulateInboxRollingHash(h, bytes32(uint256(8))); + assertEq(h, 0x0054d96b8a074a5030a5838972d0a3c04ba47cf5956348c853e02e9566233f65, "chain(0x2a, [7, 8])"); + } + + function testGenesisBucket() public { + assertEq(inbox.getCurrentBucketSeq(), 0, "genesis seq"); + + IInbox.InboxBucket memory bucket = inbox.getBucket(0); + assertEq(bucket.rollingHash, bytes32(0), "genesis rolling hash"); + assertEq(bucket.totalMsgCount, 0, "genesis total"); + assertEq(bucket.timestamp, uint64(block.timestamp), "genesis timestamp"); + assertEq(bucket.msgCount, 0, "genesis msg count"); + + vm.expectRevert(abi.encodeWithSelector(Errors.Inbox__BucketOutOfWindow.selector, 1, 0)); + inbox.getBucket(1); + } + + function testFirstMessageOpensBucketOne() public { + // Even in the deployment block, the first message must not absorb into the genesis bucket: a + // checkpoint consuming no messages needs a bucket whose rolling hash matches its parent's chain + // position, which for the first checkpoint is the zero genesis bucket. + _send(inbox, 0); + + assertEq(inbox.getCurrentBucketSeq(), 1, "current seq"); + assertEq(inbox.getBucket(0).rollingHash, bytes32(0), "genesis untouched"); + assertEq(inbox.getBucket(0).msgCount, 0, "genesis still empty"); + assertEq(inbox.getBucket(1).msgCount, 1, "bucket 1 has the message"); + } + + function testAccumulationWithinSingleBlock() public { + bytes32 leaf1 = _send(inbox, 1); + bytes32 chain1 = Hash.accumulateInboxRollingHash(bytes32(0), leaf1); + bytes32 leaf2 = _send(inbox, 2); + bytes32 chain2 = Hash.accumulateInboxRollingHash(chain1, leaf2); + bytes32 leaf3 = _send(inbox, 3); + bytes32 chain3 = Hash.accumulateInboxRollingHash(chain2, leaf3); + + assertEq(inbox.getCurrentBucketSeq(), 1, "all messages share one bucket"); + + IInbox.InboxBucket memory bucket = inbox.getBucket(1); + assertEq(bucket.rollingHash, chain3, "bucket rolling hash"); + assertEq(bucket.totalMsgCount, 3, "bucket cumulative total"); + assertEq(bucket.timestamp, uint64(block.timestamp), "bucket timestamp"); + assertEq(bucket.msgCount, 3, "bucket msg count"); + } + + function testMessageSentEventCarriesBucketData() public { + DataStructures.L2Actor memory recipient = + DataStructures.L2Actor({actor: bytes32(uint256(0x1000)), version: version}); + bytes32 content = bytes32(uint256(0x2000)); + bytes32 secretHash = bytes32(uint256(0x3000)); + + DataStructures.L1ToL2Msg memory message = DataStructures.L1ToL2Msg({ + sender: DataStructures.L1Actor(address(this), block.chainid), + recipient: recipient, + content: content, + secretHash: secretHash, + index: (FIRST_REAL_TREE_NUM - 1) * (2 ** HEIGHT) + }); + bytes32 leaf = Hash.sha256ToField(message); + bytes16 legacyHash = bytes16(keccak256(abi.encodePacked(inbox.getState().rollingHash, leaf))); + bytes32 inboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), leaf); + + vm.expectEmit(true, true, true, true, address(inbox)); + emit IInbox.MessageSent(FIRST_REAL_TREE_NUM, message.index, leaf, legacyHash, inboxRollingHash, 1); + inbox.sendL2Message(recipient, content, secretHash); + } + + function testSnapshotBoundariesAcrossBlocks() public { + _send(inbox, 1); + _send(inbox, 2); + IInbox.InboxBucket memory bucket1 = inbox.getBucket(1); + + vm.roll(block.number + 1); + vm.warp(block.timestamp + 12); + + bytes32 leaf3 = _send(inbox, 3); + + assertEq(inbox.getCurrentBucketSeq(), 2, "new block opens a new bucket"); + + // The previous bucket's snapshot is frozen at its end-of-block state. + IInbox.InboxBucket memory bucket1After = inbox.getBucket(1); + assertEq(bucket1After.rollingHash, bucket1.rollingHash, "bucket 1 rolling hash frozen"); + assertEq(bucket1After.totalMsgCount, 2, "bucket 1 total frozen"); + assertEq(bucket1After.msgCount, 2, "bucket 1 msg count frozen"); + assertEq(bucket1After.timestamp, bucket1.timestamp, "bucket 1 timestamp frozen"); + + // The new bucket continues the chain from the previous bucket. + IInbox.InboxBucket memory bucket2 = inbox.getBucket(2); + assertEq(bucket2.rollingHash, Hash.accumulateInboxRollingHash(bucket1.rollingHash, leaf3), "chain continuity"); + assertEq(bucket2.rollingHash, expectedRollingHash, "chain matches reference"); + assertEq(bucket2.totalMsgCount, 3, "cumulative total spans buckets"); + assertEq(bucket2.timestamp, uint64(block.timestamp), "bucket 2 timestamp"); + assertEq(bucket2.msgCount, 1, "bucket 2 msg count"); + } + + function testRolloverIntoNextBucket() public { + uint256 cap = MAX_MSGS_PER_BUCKET; + for (uint256 i = 0; i < cap; i++) { + _send(inbox, i); + } + assertEq(inbox.getCurrentBucketSeq(), 1, "cap messages fit in one bucket"); + IInbox.InboxBucket memory bucket1 = inbox.getBucket(1); + assertEq(bucket1.msgCount, cap, "bucket 1 full"); + + // The next message in the same L1 block spills over into a new bucket with the same timestamp. + bytes32 leaf = _send(inbox, cap); + assertEq(inbox.getCurrentBucketSeq(), 2, "rollover opened next bucket"); + + IInbox.InboxBucket memory bucket2 = inbox.getBucket(2); + assertEq(bucket2.rollingHash, Hash.accumulateInboxRollingHash(bucket1.rollingHash, leaf), "chain continuity"); + assertEq(bucket2.totalMsgCount, cap + 1, "cumulative total"); + assertEq(bucket2.timestamp, bucket1.timestamp, "same block, same timestamp"); + assertEq(bucket2.msgCount, 1, "spilled message only"); + + assertEq(inbox.getBucket(1).msgCount, cap, "bucket 1 untouched by rollover"); + } + + function testRingWraparound() public { + InboxHarness ringInbox = _deployInbox(MIN_BUCKET_RING_SIZE); + expectedRollingHash = 0; + + // One bucket per L1 block; after MIN_BUCKET_RING_SIZE + 1 buckets the ring has wrapped past bucket 1. + for (uint256 i = 1; i <= MIN_BUCKET_RING_SIZE + 1; i++) { + vm.roll(block.number + 1); + vm.warp(block.timestamp + 12); + _send(ringInbox, i); + } + + uint256 current = ringInbox.getCurrentBucketSeq(); + assertEq(current, MIN_BUCKET_RING_SIZE + 1, "one bucket per block"); + + // Buckets 0 and 1 have been overwritten: their ring slots were reused by buckets + // MIN_BUCKET_RING_SIZE and MIN_BUCKET_RING_SIZE + 1. + vm.expectRevert(abi.encodeWithSelector(Errors.Inbox__BucketOutOfWindow.selector, 0, current)); + ringInbox.getBucket(0); + vm.expectRevert(abi.encodeWithSelector(Errors.Inbox__BucketOutOfWindow.selector, 1, current)); + ringInbox.getBucket(1); + + // The live window is intact, with per-bucket data at the right ring slots. + uint64 previousTimestamp = 0; + for (uint256 seq = current - MIN_BUCKET_RING_SIZE + 1; seq <= current; seq++) { + IInbox.InboxBucket memory bucket = ringInbox.getBucket(seq); + assertEq(bucket.totalMsgCount, seq, "cumulative total"); + assertEq(bucket.msgCount, 1, "one message per bucket"); + assertGt(bucket.timestamp, previousTimestamp, "timestamps increase per bucket"); + previousTimestamp = bucket.timestamp; + } + assertEq(ringInbox.getBucket(current).rollingHash, expectedRollingHash, "chain matches reference"); + + // Buckets ahead of the current one do not exist yet. + vm.expectRevert(abi.encodeWithSelector(Errors.Inbox__BucketOutOfWindow.selector, current + 1, current)); + ringInbox.getBucket(current + 1); + } + + function testConstructorRevertsBelowRingFloor() public { + IERC20 feeAsset = new TestERC20("Fee Asset", "FA", address(this)); + vm.expectRevert("BUCKET RING TOO SMALL"); + new InboxHarness(address(this), feeAsset, version, HEIGHT, TestConstants.AZTEC_INBOX_LAG, MIN_BUCKET_RING_SIZE - 1); + } + + // Gas cost of a message absorbed into an already-open bucket (the common per-message case): the + // second message of an L1 block updates the live bucket in place without opening a new ring slot. + function testGasSendIntoExistingBucket() public { + _send(inbox, 0); + assertEq(inbox.getCurrentBucketSeq(), 1, "warmup opened bucket 1"); + + uint256 gasUsed = _measureSend(inbox, 1); + emit log_named_uint("gas: absorb into existing bucket", gasUsed); + + assertEq(inbox.getCurrentBucketSeq(), 1, "absorbed without opening a new bucket"); + } + + // Gas cost of the first message of a new L1 block: a larger timestamp opens the next bucket, + // writing a fresh ring slot on top of the per-message frontier-tree insert. + function testGasSendFirstMessageOfNewBlock() public { + _send(inbox, 0); + assertEq(inbox.getCurrentBucketSeq(), 1, "warmup opened bucket 1"); + + vm.roll(block.number + 1); + vm.warp(block.timestamp + 12); + + uint256 gasUsed = _measureSend(inbox, 1); + emit log_named_uint("gas: first message of a new L1 block", gasUsed); + + assertEq(inbox.getCurrentBucketSeq(), 2, "new block opened bucket 2"); + } + + // Gas cost of a rollover opening mid-block: once a bucket reaches MAX_MSGS_PER_BUCKET, the next + // message in the same L1 block opens a new bucket even though the timestamp is unchanged. + function testGasSendRolloverMidBlock() public { + uint256 cap = MAX_MSGS_PER_BUCKET; + for (uint256 i = 0; i < cap; i++) { + _send(inbox, i); + } + assertEq(inbox.getCurrentBucketSeq(), 1, "cap messages fit in bucket 1"); + + uint256 gasUsed = _measureSend(inbox, cap); + emit log_named_uint("gas: rollover open mid-block", gasUsed); + + assertEq(inbox.getCurrentBucketSeq(), 2, "rollover opened bucket 2"); + } + + // Gas cost of the first-ever message against a freshly deployed Inbox: the state struct, bucket 1, and the + // first frontier-tree slots are all written cold. This is the cold-storage case, not the global worst-case + // insert — later frontier indices with more levels to hash can cost more. + function testGasSendFirstEverMessage() public { + assertEq(inbox.getCurrentBucketSeq(), 0, "no message sent yet"); + + uint256 gasUsed = _measureSend(inbox, 0); + emit log_named_uint("gas: first-ever message", gasUsed); + + assertEq(inbox.getCurrentBucketSeq(), 1, "first message opened bucket 1"); + } +} diff --git a/l1-contracts/test/Rollup.t.sol b/l1-contracts/test/Rollup.t.sol index dafbe7b9a5d3..2456474939b7 100644 --- a/l1-contracts/test/Rollup.t.sol +++ b/l1-contracts/test/Rollup.t.sol @@ -12,7 +12,7 @@ import {Registry} from "@aztec/governance/Registry.sol"; import {Inbox} from "@aztec/core/messagebridge/Inbox.sol"; import {Outbox} from "@aztec/core/messagebridge/Outbox.sol"; import {Errors} from "@aztec/core/libraries/Errors.sol"; -import {ProposedHeader} from "@aztec/core/libraries/rollup/ProposedHeaderLib.sol"; +import {ProposedHeader, ProposedHeaderLib} from "@aztec/core/libraries/rollup/ProposedHeaderLib.sol"; import { IRollupCore, @@ -874,6 +874,52 @@ contract RollupTest is RollupBase { assertEq(outbox.getRootData(Epoch.wrap(0), 2), outHash2, "Root at K=2 should be outHash2"); } + // getEpochProofPublicInputs is the view that the prover-publisher calls off-chain to validate its inputs before + // submitting. Because the fee recipient/value public inputs are taken from the supplied headers, the header check + // must run here too - not only on the submit path - so a mismatch is caught before publishing rather than reverting + // on-chain. + function testGetEpochProofPublicInputsVerifiesHeaders() public setUpFor("empty_checkpoint_1") { + _proposeCheckpoint("empty_checkpoint_1", 1); + + DecoderBase.Data memory data = load("empty_checkpoint_1").checkpoint; + CheckpointLog memory checkpoint = rollup.getCheckpoint(0); + + PublicInputArgs memory args = PublicInputArgs({ + previousArchive: checkpoint.archive, + endArchive: data.archive, + outHash: data.header.outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: data.header.inboxRollingHash, + proverId: address(0) + }); + + ProposedHeader[] memory headers = new ProposedHeader[](1); + headers[0] = proposedHeaders[1]; + + // With the canonical header, the getter assembles the public inputs, sourcing the fee recipient/value from the + // header. + bytes32[] memory publicInputs = rollup.getEpochProofPublicInputs(1, 1, args, headers, data.batchedBlobInputs); + assertEq(publicInputs.length, Constants.ROOT_ROLLUP_PUBLIC_INPUTS_LENGTH, "Unexpected public inputs length"); + + uint256 feesOffset = 5 + Constants.MAX_CHECKPOINTS_PER_EPOCH; + assertEq( + publicInputs[feesOffset], bytes32(uint256(uint160(headers[0].coinbase))), "Coinbase not sourced from header" + ); + assertEq( + publicInputs[feesOffset + 1], bytes32(headers[0].accumulatedFees), "Accumulated fees not sourced from header" + ); + + // Tamper a fee field so the header no longer hashes to the stored value; the getter must reject it. + bytes32 expectedHeaderHash = ProposedHeaderLib.hash(headers[0]); + headers[0].accumulatedFees += 1; + bytes32 providedHeaderHash = ProposedHeaderLib.hash(headers[0]); + + vm.expectRevert( + abi.encodeWithSelector(Errors.Rollup__InvalidCheckpointHeader.selector, expectedHeaderHash, providedHeaderHash) + ); + rollup.getEpochProofPublicInputs(1, 1, args, headers, data.batchedBlobInputs); + } + function _submitEpochProof( uint256 _start, uint256 _end, @@ -895,7 +941,12 @@ contract RollupTest is RollupBase { address _prover ) internal { PublicInputArgs memory args = PublicInputArgs({ - previousArchive: _prevArchive, endArchive: _archive, outHash: _outHash, proverId: _prover + previousArchive: _prevArchive, + endArchive: _archive, + outHash: _outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, + proverId: _prover }); uint256 size = _end - _start + 1; diff --git a/l1-contracts/test/base/DecoderBase.sol b/l1-contracts/test/base/DecoderBase.sol index 24e74617950d..7abcb375c1aa 100644 --- a/l1-contracts/test/base/DecoderBase.sol +++ b/l1-contracts/test/base/DecoderBase.sol @@ -47,6 +47,7 @@ contract DecoderBase is TestBase { bytes32 feeRecipient; GasFees gasFees; bytes32 inHash; + bytes32 inboxRollingHash; bytes32 lastArchiveRoot; bytes32 outHash; uint256 slotNumber; @@ -104,6 +105,7 @@ contract DecoderBase is TestBase { blockHeadersHash: full.checkpoint.header.blockHeadersHash, blobsHash: full.checkpoint.header.blobsHash, inHash: full.checkpoint.header.inHash, + inboxRollingHash: full.checkpoint.header.inboxRollingHash, outHash: full.checkpoint.header.outHash, slotNumber: Slot.wrap(full.checkpoint.header.slotNumber), timestamp: Timestamp.wrap(full.checkpoint.header.timestamp), diff --git a/l1-contracts/test/base/RollupBase.sol b/l1-contracts/test/base/RollupBase.sol index 78829b61135d..f75b9875d013 100644 --- a/l1-contracts/test/base/RollupBase.sol +++ b/l1-contracts/test/base/RollupBase.sol @@ -78,6 +78,8 @@ contract RollupBase is DecoderBase { previousArchive: parentCheckpointLog.archive, endArchive: endFull.checkpoint.archive, outHash: endFull.checkpoint.header.outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, proverId: _prover }); diff --git a/l1-contracts/test/benchmark/happy.t.sol b/l1-contracts/test/benchmark/happy.t.sol index e558b9b6f2f2..f5f0a900b888 100644 --- a/l1-contracts/test/benchmark/happy.t.sol +++ b/l1-contracts/test/benchmark/happy.t.sol @@ -511,6 +511,8 @@ contract BenchmarkRollupTest is FeeModelTestPoints, DecoderBase { previousArchive: rollup.getCheckpoint(start).archive, endArchive: endCheckpoint.archive, outHash: endCheckpoint.outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, proverId: address(0) }); diff --git a/l1-contracts/test/compression/PreHeating.t.sol b/l1-contracts/test/compression/PreHeating.t.sol index e3b891e195b2..7cf07a0c9298 100644 --- a/l1-contracts/test/compression/PreHeating.t.sol +++ b/l1-contracts/test/compression/PreHeating.t.sol @@ -263,6 +263,8 @@ contract PreHeatingTest is FeeModelTestPoints, DecoderBase { previousArchive: rollup.getCheckpoint(start).archive, endArchive: endCheckpoint.archive, outHash: endCheckpoint.outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, proverId: address(0) }); diff --git a/l1-contracts/test/escape-hatch/integration/EscapeHatchIntegrationBase.sol b/l1-contracts/test/escape-hatch/integration/EscapeHatchIntegrationBase.sol index 61f679d78805..7b2e16301bbb 100644 --- a/l1-contracts/test/escape-hatch/integration/EscapeHatchIntegrationBase.sol +++ b/l1-contracts/test/escape-hatch/integration/EscapeHatchIntegrationBase.sol @@ -142,6 +142,7 @@ abstract contract EscapeHatchIntegrationBase is ValidatorSelectionTestBase { blockHeadersHash: full.checkpoint.header.blockHeadersHash, blobsHash: full.checkpoint.header.blobsHash, inHash: full.checkpoint.header.inHash, + inboxRollingHash: full.checkpoint.header.inboxRollingHash, outHash: full.checkpoint.header.outHash, slotNumber: slotNumber, timestamp: rollup.getTimestampForSlot(slotNumber), @@ -324,6 +325,8 @@ abstract contract EscapeHatchIntegrationBase is ValidatorSelectionTestBase { previousArchive: previousArchive, endArchive: endArchive, outHash: endFull.checkpoint.header.outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, proverId: _prover }); diff --git a/l1-contracts/test/escape-hatch/integration/regression/OutHashValidationSkipped.t.sol b/l1-contracts/test/escape-hatch/integration/regression/OutHashValidationSkipped.t.sol index 72b48358d16a..5baa9903924d 100644 --- a/l1-contracts/test/escape-hatch/integration/regression/OutHashValidationSkipped.t.sol +++ b/l1-contracts/test/escape-hatch/integration/regression/OutHashValidationSkipped.t.sol @@ -60,6 +60,8 @@ contract OutHashValidationSkippedTest is EscapeHatchIntegrationBase { previousArchive: rollup.archiveAt(0), endArchive: rollup.archiveAt(1), outHash: wrongOutHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, proverId: address(this) }); diff --git a/l1-contracts/test/escape-hatch/integration/submitEpochRootProof.t.sol b/l1-contracts/test/escape-hatch/integration/submitEpochRootProof.t.sol index 4e57aef3f5f6..6e46a60fad48 100644 --- a/l1-contracts/test/escape-hatch/integration/submitEpochRootProof.t.sol +++ b/l1-contracts/test/escape-hatch/integration/submitEpochRootProof.t.sol @@ -112,7 +112,12 @@ contract submitEpochRootProofTest is EscapeHatchIntegrationBase { bytes32 outHash = rollup.getCheckpoint(1).outHash; PublicInputArgs memory args = PublicInputArgs({ - previousArchive: previousArchive, endArchive: endArchive, outHash: outHash, proverId: address(this) + previousArchive: previousArchive, + endArchive: endArchive, + outHash: outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, + proverId: address(this) }); ProposedHeader[] memory headers = new ProposedHeader[](1); diff --git a/l1-contracts/test/fee_portal/depositToAztecPublic.t.sol b/l1-contracts/test/fee_portal/depositToAztecPublic.t.sol index 0a4b0c99374d..61a5ff73a90f 100644 --- a/l1-contracts/test/fee_portal/depositToAztecPublic.t.sol +++ b/l1-contracts/test/fee_portal/depositToAztecPublic.t.sol @@ -111,8 +111,9 @@ contract DepositToAztecPublic is Test { bytes16 expectedHash = bytes16(keccak256(abi.encodePacked(inbox.getState().rollingHash, expectedKey))); uint256 expectedInProgress = Constants.INITIAL_CHECKPOINT_NUMBER + TestConstants.AZTEC_INBOX_LAG; + bytes32 expectedInboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), expectedKey); vm.expectEmit(true, true, true, true, address(inbox)); - emit IInbox.MessageSent(expectedInProgress, expectedIndex, expectedKey, expectedHash); + emit IInbox.MessageSent(expectedInProgress, expectedIndex, expectedKey, expectedHash, expectedInboxRollingHash, 1); vm.expectEmit(true, true, true, true, address(feeJuicePortal)); emit IFeeJuicePortal.DepositToAztecPublic(to, amount, secretHash, expectedKey, expectedIndex); diff --git a/l1-contracts/test/fees/FeeRollup.t.sol b/l1-contracts/test/fees/FeeRollup.t.sol index e34b85ed6677..26d858ee7e71 100644 --- a/l1-contracts/test/fees/FeeRollup.t.sol +++ b/l1-contracts/test/fees/FeeRollup.t.sol @@ -236,6 +236,8 @@ contract FeeRollupTest is FeeModelTestPoints, DecoderBase { previousArchive: rollup.getCheckpoint(_start).archive, endArchive: endCheckpoint.archive, outHash: endCheckpoint.outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, proverId: address(0) }); diff --git a/l1-contracts/test/fixtures/empty_checkpoint_1.json b/l1-contracts/test/fixtures/empty_checkpoint_1.json index a59c66145db8..1f829f1b819b 100644 --- a/l1-contracts/test/fixtures/empty_checkpoint_1.json +++ b/l1-contracts/test/fixtures/empty_checkpoint_1.json @@ -35,6 +35,7 @@ "blockHeadersHash": "0x2e3e0911389bc48fa8126a93273d016cc7dc08019f8ffc5f1f5ae7d90745eaa2", "blobsHash": "0x00e5b752fe6bc2154155ff3a979c4c5fa91d3ac0d716169ac521e1560fd83b2b", "inHash": "0x00de7b349d2306334734e4f58b1302a6ed5a6c796a706f6597a5641b6d468223", + "inboxRollingHash": "0x00cad6497cf81748167158f149ba70c31f34c68b0ae1b156117de63e073d14b5", "outHash": "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093", "slotNumber": 99, "timestamp": 1776857814, @@ -47,7 +48,7 @@ "totalManaUsed": 0, "accumulatedFees": 0 }, - "headerHash": "0x0069eb49ccf7b0dd2902a19712dd167fd3b5d890df7f0711fdcfe4d2987838ad", + "headerHash": "0x0002fc455005d993521be4e6f8ed92d1e0b50e58b21445881c87d02ed51a1e4c", "numTxs": 0 } -} \ No newline at end of file +} diff --git a/l1-contracts/test/fixtures/empty_checkpoint_2.json b/l1-contracts/test/fixtures/empty_checkpoint_2.json index 52323cc08975..d2dcd961b92f 100644 --- a/l1-contracts/test/fixtures/empty_checkpoint_2.json +++ b/l1-contracts/test/fixtures/empty_checkpoint_2.json @@ -35,6 +35,7 @@ "blockHeadersHash": "0x0b3bda1754ca30707b8c0bbe72760c68e574cf23309e7e4fd7cabea36b4078da", "blobsHash": "0x000e9acabf609c9c113078ecb383ba6310573ce246958b605452132617d2c960", "inHash": "0x006504de282a40084bb8098456a915c645d53482d351db52fa9433b6cd638763", + "inboxRollingHash": "0x0080dbf2bd9576e81fd99fc0f9d35bfd7fc15a6221d0b6e1e92a1884f14d0c84", "outHash": "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093", "slotNumber": 102, "timestamp": 1776858030, @@ -47,7 +48,7 @@ "totalManaUsed": 0, "accumulatedFees": 0 }, - "headerHash": "0x0004d4907090fd10f0c7fa759b7ce89c3b7055385423b585c5f7e959c17290ef", + "headerHash": "0x00120ecaf7a72f61adf3c8ee180acd930401221668a4792a8f91584755840d16", "numTxs": 0 } -} \ No newline at end of file +} diff --git a/l1-contracts/test/fixtures/mixed_checkpoint_1.json b/l1-contracts/test/fixtures/mixed_checkpoint_1.json index 6e47dc89c331..b1604aceb038 100644 --- a/l1-contracts/test/fixtures/mixed_checkpoint_1.json +++ b/l1-contracts/test/fixtures/mixed_checkpoint_1.json @@ -68,6 +68,7 @@ "blockHeadersHash": "0x087b6f59388fa4207876ee1b50521ff838d6eed422d0ad07ff996393f32a77e6", "blobsHash": "0x001bef3ff3f657c565ff86d5072186f7f2bfddb8a31ca0714562c164fe954d84", "inHash": "0x00de7b349d2306334734e4f58b1302a6ed5a6c796a706f6597a5641b6d468223", + "inboxRollingHash": "0x00cad6497cf81748167158f149ba70c31f34c68b0ae1b156117de63e073d14b5", "outHash": "0x00cffdbb0e7f5e164d314d781d38ae31230910a3bae4c34e7df6222df71b1539", "slotNumber": 99, "timestamp": 1776857848, @@ -80,7 +81,7 @@ "totalManaUsed": 0, "accumulatedFees": 0 }, - "headerHash": "0x003ce6d2bb91ea8852841510f5485595dfbddbaa0420e083caf37f182be2140a", + "headerHash": "0x00c1431d117825d25f8169e35eb70ed4b16c0fc4b3cac85506852c240d03740e", "numTxs": 4 } -} \ No newline at end of file +} diff --git a/l1-contracts/test/fixtures/mixed_checkpoint_2.json b/l1-contracts/test/fixtures/mixed_checkpoint_2.json index 577e335441eb..d2125d5786a4 100644 --- a/l1-contracts/test/fixtures/mixed_checkpoint_2.json +++ b/l1-contracts/test/fixtures/mixed_checkpoint_2.json @@ -68,6 +68,7 @@ "blockHeadersHash": "0x144dbe32a03df9ccc672207c93cd22099eb91e44a71e1676148cd3c6c6c98b9e", "blobsHash": "0x008bd0b669b942b57ccf85d3401214db65cde3608afa0b2ae0e57f35ec60d72e", "inHash": "0x006504de282a40084bb8098456a915c645d53482d351db52fa9433b6cd638763", + "inboxRollingHash": "0x0080dbf2bd9576e81fd99fc0f9d35bfd7fc15a6221d0b6e1e92a1884f14d0c84", "outHash": "0x008a85da85a596471f2e5fe402fde332723da8d24b6e7affd60d16c7cb7e9020", "slotNumber": 102, "timestamp": 1776858064, @@ -80,7 +81,7 @@ "totalManaUsed": 0, "accumulatedFees": 0 }, - "headerHash": "0x00eb0f37a51d2df835ea48d6cdde28398df86078d8507d467f34434dac062456", + "headerHash": "0x00ab5faa05cb38faa2cd1fc62c40007f64594c9fdc3bb8b7b478a351a7c7dc5a", "numTxs": 4 } -} \ No newline at end of file +} diff --git a/l1-contracts/test/fixtures/single_tx_checkpoint_1.json b/l1-contracts/test/fixtures/single_tx_checkpoint_1.json index 83aa2756dd96..6d409f05d521 100644 --- a/l1-contracts/test/fixtures/single_tx_checkpoint_1.json +++ b/l1-contracts/test/fixtures/single_tx_checkpoint_1.json @@ -44,6 +44,7 @@ "blockHeadersHash": "0x07db5c24565ad9a2c9d39ef7d9a4446e9742d6090567ff28aef9a45f4738a5cb", "blobsHash": "0x00ec2400a7cfc9d975cb0802980d49387588738160a0cf0301f07e1abad6456c", "inHash": "0x00de7b349d2306334734e4f58b1302a6ed5a6c796a706f6597a5641b6d468223", + "inboxRollingHash": "0x00cad6497cf81748167158f149ba70c31f34c68b0ae1b156117de63e073d14b5", "outHash": "0x007c92c6cf05665e1c02a305370a4d38bcb8b555261c6b39c862f8c067d6bcb7", "slotNumber": 99, "timestamp": 1776857833, @@ -56,7 +57,7 @@ "totalManaUsed": 0, "accumulatedFees": 0 }, - "headerHash": "0x00628120df9716928e25a69ca7b1ac2497f22fdaab439f64315ad4daf7bc5191", + "headerHash": "0x0072a35395a79027db315321cbdaba5bc0b070979c3395b7369ec902ca48d9b2", "numTxs": 1 } -} \ No newline at end of file +} diff --git a/l1-contracts/test/fixtures/single_tx_checkpoint_2.json b/l1-contracts/test/fixtures/single_tx_checkpoint_2.json index b4b8e0a60a51..dc1244dcd73c 100644 --- a/l1-contracts/test/fixtures/single_tx_checkpoint_2.json +++ b/l1-contracts/test/fixtures/single_tx_checkpoint_2.json @@ -44,6 +44,7 @@ "blockHeadersHash": "0x12813725f2d16ce92088d2401ffa4a53ce6061bf75b77320ca7b8ef6c5145adf", "blobsHash": "0x002b8ae4c9f405529e2b689b829852ad52f77acdac57d1dbac3dabea1760affc", "inHash": "0x006504de282a40084bb8098456a915c645d53482d351db52fa9433b6cd638763", + "inboxRollingHash": "0x0080dbf2bd9576e81fd99fc0f9d35bfd7fc15a6221d0b6e1e92a1884f14d0c84", "outHash": "0x0007eac1d76cddf92b28b8f11cd292f199f35dfc588376092986575cef487f59", "slotNumber": 102, "timestamp": 1776858049, @@ -56,7 +57,7 @@ "totalManaUsed": 0, "accumulatedFees": 0 }, - "headerHash": "0x00f2d5075ed8fdbb50bc0171790cb495308b229325c0aa3e1c3fadd5772d11f4", + "headerHash": "0x000b3c0bf27d3123a81b66570e4b63734cb06bbfd260a70fabbbfd41dec13255", "numTxs": 1 } -} \ No newline at end of file +} diff --git a/l1-contracts/test/harnesses/InboxHarness.sol b/l1-contracts/test/harnesses/InboxHarness.sol index 5257aa8a196b..1ba2b3b446ca 100644 --- a/l1-contracts/test/harnesses/InboxHarness.sol +++ b/l1-contracts/test/harnesses/InboxHarness.sol @@ -10,8 +10,8 @@ import {FrontierLib} from "@aztec/core/libraries/crypto/FrontierLib.sol"; contract InboxHarness is Inbox { using FrontierLib for FrontierLib.Tree; - constructor(address _rollup, IERC20 _feeAsset, uint256 _version, uint256 _height, uint256 _lag) - Inbox(_rollup, _feeAsset, _version, _height, _lag) + constructor(address _rollup, IERC20 _feeAsset, uint256 _version, uint256 _height, uint256 _lag, uint256 _ringSize) + Inbox(_rollup, _feeAsset, _version, _height, _lag, _ringSize) {} function getSize() external view returns (uint256) { diff --git a/l1-contracts/test/harnesses/TestConstants.sol b/l1-contracts/test/harnesses/TestConstants.sol index c0d7a6738981..44aee456e1d4 100644 --- a/l1-contracts/test/harnesses/TestConstants.sol +++ b/l1-contracts/test/harnesses/TestConstants.sol @@ -26,6 +26,7 @@ library TestConstants { uint256 internal constant AZTEC_LAG_IN_EPOCHS_FOR_VALIDATOR_SET = 3; uint256 internal constant AZTEC_LAG_IN_EPOCHS_FOR_RANDAO = 2; uint256 internal constant AZTEC_INBOX_LAG = 2; + uint256 internal constant AZTEC_INBOX_BUCKET_RING_SIZE = 1024; uint256 internal constant AZTEC_PROOF_SUBMISSION_EPOCHS = 1; uint256 internal constant AZTEC_SLASHING_QUORUM = 17; // Must be > ROUND_SIZE / 2 (ROUND_SIZE derived from // EPOCH_DURATION) diff --git a/l1-contracts/test/portals/TokenPortal.t.sol b/l1-contracts/test/portals/TokenPortal.t.sol index 47e341d38f68..cb6bf77e3bd6 100644 --- a/l1-contracts/test/portals/TokenPortal.t.sol +++ b/l1-contracts/test/portals/TokenPortal.t.sol @@ -124,10 +124,11 @@ contract TokenPortalTest is Test { bytes32 expectedLeaf = expectedMessage.sha256ToField(); bytes16 expectedHash = bytes16(keccak256(abi.encodePacked(inbox.getState().rollingHash, expectedLeaf))); + bytes32 expectedInboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), expectedLeaf); // Check the event was emitted vm.expectEmit(true, true, true, true); // event we expect - emit IInbox.MessageSent(FIRST_REAL_TREE_NUM, expectedIndex, expectedLeaf, expectedHash); + emit IInbox.MessageSent(FIRST_REAL_TREE_NUM, expectedIndex, expectedLeaf, expectedHash, expectedInboxRollingHash, 1); // event we will get // Perform op @@ -150,11 +151,12 @@ contract TokenPortalTest is Test { DataStructures.L1ToL2Msg memory expectedMessage = _createExpectedMintPublicL1ToL2Message(expectedIndex); bytes32 expectedLeaf = expectedMessage.sha256ToField(); bytes16 expectedHash = bytes16(keccak256(abi.encodePacked(inbox.getState().rollingHash, expectedLeaf))); + bytes32 expectedInboxRollingHash = Hash.accumulateInboxRollingHash(bytes32(0), expectedLeaf); // Check the event was emitted vm.expectEmit(true, true, true, true); // event we expect - emit IInbox.MessageSent(FIRST_REAL_TREE_NUM, expectedIndex, expectedLeaf, expectedHash); + emit IInbox.MessageSent(FIRST_REAL_TREE_NUM, expectedIndex, expectedLeaf, expectedHash, expectedInboxRollingHash, 1); // Perform op (bytes32 leaf, uint256 index) = tokenPortal.depositToAztecPublic(to, amount, secretHashForL2MessageConsumption); diff --git a/l1-contracts/test/rollup/ProposeInboxConsumption.t.sol b/l1-contracts/test/rollup/ProposeInboxConsumption.t.sol new file mode 100644 index 000000000000..7d1e8a00c032 --- /dev/null +++ b/l1-contracts/test/rollup/ProposeInboxConsumption.t.sol @@ -0,0 +1,303 @@ +// SPDX-License-Identifier: Apache-2.0 +// Copyright 2024 Aztec Labs. +pragma solidity >=0.8.27; + +import {Test} from "forge-std/Test.sol"; +import {TestERC20} from "src/mock/TestERC20.sol"; +import {IERC20} from "@oz/token/ERC20/IERC20.sol"; +import {IInbox, MAX_MSGS_PER_BUCKET} from "@aztec/core/interfaces/messagebridge/IInbox.sol"; +import { + ProposeLib, + INBOX_LAG_SECONDS, + MAX_L1_TO_L2_MSGS_PER_CHECKPOINT +} from "@aztec/core/libraries/rollup/ProposeLib.sol"; +import {TimeLib, Slot, Timestamp} from "@aztec/core/libraries/TimeLib.sol"; +import {Errors} from "@aztec/core/libraries/Errors.sol"; +import {DataStructures} from "@aztec/core/libraries/DataStructures.sol"; +import {MIN_BUCKET_RING_SIZE} from "@aztec/core/messagebridge/Inbox.sol"; +import {InboxHarness} from "../harnesses/InboxHarness.sol"; +import {TestConstants} from "../harnesses/TestConstants.sol"; + +contract ProposeLibHarness { + constructor(uint256 _genesisTime, uint256 _slotDuration, uint256 _epochDuration) { + TimeLib.initialize(_genesisTime, _slotDuration, _epochDuration, 1); + } + + function validateInboxConsumption( + IInbox _inbox, + bytes32 _inboxRollingHash, + uint256 _bucketHint, + Slot _slotNumber, + uint256 _parentTotalMsgCount + ) external view returns (uint256) { + return ProposeLib.validateInboxConsumption( + _inbox, _inboxRollingHash, _bucketHint, _slotNumber, _parentTotalMsgCount + ); + } +} + +contract ProposeInboxConsumptionTest is Test { + uint256 internal constant GENESIS_TIME = 100_000; + uint256 internal constant SLOT_DURATION = 36; + uint256 internal constant EPOCH_DURATION = 32; + uint256 internal constant HEIGHT = 10; + + Slot internal constant SLOT = Slot.wrap(10); + + ProposeLibHarness internal rollup; + InboxHarness internal inbox; + uint256 internal version = 0; + + // Start of the build frame for a checkpoint proposed in SLOT: it is built during the previous slot. + uint256 internal buildFrameStart = GENESIS_TIME + (Slot.unwrap(SLOT) - 1) * SLOT_DURATION; + // Buckets at or before the cutoff must be consumed by the checkpoint. + uint256 internal cutoff = buildFrameStart - INBOX_LAG_SECONDS; + + function setUp() public { + vm.warp(GENESIS_TIME); + rollup = new ProposeLibHarness(GENESIS_TIME, SLOT_DURATION, EPOCH_DURATION); + inbox = _deployInbox(TestConstants.AZTEC_INBOX_BUCKET_RING_SIZE); + } + + function _deployInbox(uint256 _ringSize) internal returns (InboxHarness) { + IERC20 feeAsset = new TestERC20("Fee Asset", "FA", address(this)); + return new InboxHarness(address(rollup), feeAsset, version, HEIGHT, TestConstants.AZTEC_INBOX_LAG, _ringSize); + } + + function _send(uint256 _salt) internal { + inbox.sendL2Message( + DataStructures.L2Actor({actor: bytes32(uint256(0x1000 + _salt)), version: version}), + bytes32(uint256(0x2000 + _salt)), + bytes32(uint256(0x3000 + _salt)) + ); + } + + function _sendMany(uint256 _count) internal { + for (uint256 i = 0; i < _count; i++) { + _send(i); + } + } + + function testEmptyInbox() public { + // The genesis bucket carries the Inbox's deployment timestamp and never absorbs messages, so it is settled + // from the start: referencing it works even in the L1 block the Inbox was deployed in. + uint256 consumed = rollup.validateInboxConsumption(inbox, bytes32(0), 0, SLOT, 0); + assertEq(consumed, 0, "consumed nothing on empty inbox"); + } + + function testEmptyInboxRejectsNonZeroHash() public { + vm.expectRevert( + abi.encodeWithSelector(Errors.Rollup__InvalidInboxRollingHash.selector, bytes32(0), bytes32(uint256(1))) + ); + rollup.validateInboxConsumption(inbox, bytes32(uint256(1)), 0, SLOT, 0); + } + + function testConsumeUpToLatestBucket() public { + vm.warp(cutoff); + _sendMany(3); + bytes32 endHash = inbox.getBucket(1).rollingHash; + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + uint256 consumed = rollup.validateInboxConsumption(inbox, endHash, 1, SLOT, 0); + assertEq(consumed, 3, "consumed all three messages"); + } + + function testExactCutoffBucketMustBeConsumed() public { + // A bucket created exactly at the cutoff is the "latest bucket at/before build-frame start minus lag": + // consuming nothing is no longer allowed. + vm.warp(cutoff); + _send(0); + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__UnconsumedInboxMessages.selector, 1)); + rollup.validateInboxConsumption(inbox, bytes32(0), 0, SLOT, 0); + } + + function testBucketPastCutoffNeedNotBeConsumed() public { + vm.warp(cutoff + 1); + _send(0); + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + uint256 consumed = rollup.validateInboxConsumption(inbox, bytes32(0), 0, SLOT, 0); + assertEq(consumed, 0, "nothing consumed"); + } + + function testCapEscape() public { + // One more message than the checkpoint cap, all before the cutoff. They spill over into buckets + // 1..4 of 256 (the per-bucket cap) plus bucket 5 with the single excess message. + vm.warp(cutoff - 100); + _sendMany(MAX_L1_TO_L2_MSGS_PER_CHECKPOINT + 1); + assertEq(inbox.getCurrentBucketSeq(), 5, "expected five buckets"); + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + + // Consuming through bucket 4 exhausts the cap exactly, so bucket 5 escapes the censorship assert + // even though it is old. + bytes32 endHash = inbox.getBucket(4).rollingHash; + uint256 consumed = rollup.validateInboxConsumption(inbox, endHash, 4, SLOT, 0); + assertEq(consumed, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT, "consumed the full cap"); + } + + function testNoCapEscapeAtExactCap() public { + vm.warp(cutoff - 100); + _sendMany(MAX_L1_TO_L2_MSGS_PER_CHECKPOINT + 1); + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + + // Stopping at bucket 3 leaves bucket 4 unconsumed; consuming through it would total exactly the cap, + // which fits in one checkpoint, so there is no escape and the old bucket must be consumed. + bytes32 endHash = inbox.getBucket(3).rollingHash; + vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__UnconsumedInboxMessages.selector, 4)); + rollup.validateInboxConsumption(inbox, endHash, 3, SLOT, 0); + } + + function testCapEscapeAccountsForParentTotal() public { + // Same layout as testCapEscape, but the parent checkpoint had already consumed one message: + // buckets 2..5 then hold cap messages total, which fit in one checkpoint, so no escape from bucket 1. + vm.warp(cutoff - 100); + _sendMany(MAX_L1_TO_L2_MSGS_PER_CHECKPOINT + 1); + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + + bytes32 endHash = inbox.getBucket(4).rollingHash; + vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__UnconsumedInboxMessages.selector, 5)); + rollup.validateInboxConsumption(inbox, endHash, 4, SLOT, 1); + } + + function testStaleHashRejection() public { + vm.warp(cutoff); + _send(0); + vm.roll(block.number + 1); + vm.warp(cutoff + 10); + _send(1); + + bytes32 staleHash = inbox.getBucket(1).rollingHash; + bytes32 currentHash = inbox.getBucket(2).rollingHash; + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__InvalidInboxRollingHash.selector, currentHash, staleHash)); + rollup.validateInboxConsumption(inbox, staleHash, 2, SLOT, 0); + } + + function testUnknownHashRejection() public { + vm.warp(cutoff); + _send(0); + + bytes32 unknownHash = bytes32(uint256(0xdead)); + bytes32 bucketHash = inbox.getBucket(1).rollingHash; + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__InvalidInboxRollingHash.selector, bucketHash, unknownHash)); + rollup.validateInboxConsumption(inbox, unknownHash, 1, SLOT, 0); + } + + function testHintBeyondCurrentBucketRejected() public { + vm.warp(cutoff); + _send(0); + + vm.expectRevert(abi.encodeWithSelector(Errors.Inbox__BucketOutOfWindow.selector, 2, 1)); + rollup.validateInboxConsumption(inbox, bytes32(0), 2, SLOT, 0); + } + + function testHintOnOverwrittenBucketRejected() public { + InboxHarness ringInbox = _deployInbox(MIN_BUCKET_RING_SIZE); + + // One bucket per L1 block; after MIN_BUCKET_RING_SIZE + 1 buckets the ring has wrapped past bucket 1, + // so a hint pointing at it must be rejected before any cutoff logic runs. + for (uint256 i = 1; i <= MIN_BUCKET_RING_SIZE + 1; i++) { + vm.roll(block.number + 1); + vm.warp(block.timestamp + 1); + ringInbox.sendL2Message( + DataStructures.L2Actor({actor: bytes32(uint256(0x1000 + i)), version: version}), + bytes32(uint256(0x2000 + i)), + bytes32(uint256(0x3000 + i)) + ); + } + + // No proposal-time warp: the loop above has already moved past SLOT's proposal time, and the revert fires + // in getBucket before any cutoff logic reads the clock. + vm.expectRevert(abi.encodeWithSelector(Errors.Inbox__BucketOutOfWindow.selector, 1, MIN_BUCKET_RING_SIZE + 1)); + rollup.validateInboxConsumption(ringInbox, bytes32(0), 1, SLOT, 0); + } + + function testCurrentBlockBucketRejected() public { + // A proposer that bundles `sendL2Message` and `propose` into a single L1 transaction can reference a + // bucket that is still accumulating and then mutate it with a trailing send. The snapshot the checkpoint + // committed to would afterwards exist nowhere: not on L1, where it was overwritten in place, and not in + // any node, which only ever observes a bucket's end-of-block state. + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + _send(0); + bytes32 liveHash = inbox.getBucket(1).rollingHash; + + vm.expectRevert(abi.encodeWithSelector(Errors.Rollup__InboxBucketStillMutable.selector, 1)); + rollup.validateInboxConsumption(inbox, liveHash, 1, SLOT, 0); + + // Nothing prevents the trailing send that erases the referenced snapshot, so the reference itself is what + // has to be rejected. + _send(1); + assertTrue(inbox.getBucket(1).rollingHash != liveHash, "bucket mutated in place within one L1 block"); + } + + function testFullBucketInCurrentBlockAccepted() public { + // A bucket at the per-bucket cap cannot absorb another message: the next send in the same L1 block opens + // a new bucket, so the snapshot is already final and referencing it within that block is safe. + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + uint256 cap = MAX_MSGS_PER_BUCKET; + _sendMany(cap); + assertEq(inbox.getBucket(1).msgCount, cap, "bucket 1 is at the per-bucket cap"); + assertEq(inbox.getBucket(1).timestamp, block.timestamp, "bucket 1 was opened in this L1 block"); + + bytes32 endHash = inbox.getBucket(1).rollingHash; + uint256 consumed = rollup.validateInboxConsumption(inbox, endHash, 1, SLOT, 0); + assertEq(consumed, cap, "a full bucket is consumable in the block it was opened in"); + } + + function testConsumeBackwardsReverts() public { + // Buckets 1 and 2 exist with distinct cumulative totals. A proposal that references bucket 1 while its + // parent already consumed through bucket 2 would move consumption backwards. + vm.warp(cutoff - 100); + _send(0); + vm.roll(block.number + 1); + vm.warp(cutoff - 50); + _send(1); + + uint256 parentTotal = inbox.getBucket(2).totalMsgCount; + uint256 bucketTotal = inbox.getBucket(1).totalMsgCount; + bytes32 bucketHash = inbox.getBucket(1).rollingHash; + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + vm.expectRevert( + abi.encodeWithSelector(Errors.Rollup__InboxConsumptionBehindParent.selector, parentTotal, bucketTotal) + ); + rollup.validateInboxConsumption(inbox, bucketHash, 1, SLOT, parentTotal); + } + + function testEqualReferenceConsumesNothing() public { + // The parent already consumed the current bucket; re-referencing it with an equal parent total consumes + // nothing and returns the unchanged cumulative total. No newer pre-cutoff bucket exists. + vm.warp(cutoff); + _sendMany(2); + uint256 total = inbox.getBucket(1).totalMsgCount; + bytes32 endHash = inbox.getBucket(1).rollingHash; + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + uint256 consumed = rollup.validateInboxConsumption(inbox, endHash, 1, SLOT, total); + assertEq(consumed, total, "equal reference returns the unchanged total"); + } + + function testCapUpperBoundReverts() public { + // One more message than the checkpoint cap, all before the cutoff, referenced in a single proposal from + // a fresh parent: the consumed delta exceeds what the circuits can insert. + vm.warp(cutoff - 100); + _sendMany(MAX_L1_TO_L2_MSGS_PER_CHECKPOINT + 1); + assertEq(inbox.getCurrentBucketSeq(), 5, "expected five buckets"); + + bytes32 endHash = inbox.getBucket(5).rollingHash; + + vm.warp(GENESIS_TIME + Slot.unwrap(SLOT) * SLOT_DURATION); + vm.expectRevert( + abi.encodeWithSelector(Errors.Rollup__TooManyInboxMessagesConsumed.selector, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT + 1) + ); + rollup.validateInboxConsumption(inbox, endHash, 5, SLOT, 0); + } +} diff --git a/l1-contracts/test/validator-selection/ValidatorSelection.t.sol b/l1-contracts/test/validator-selection/ValidatorSelection.t.sol index 0062c9b6e58f..722e97dc320a 100644 --- a/l1-contracts/test/validator-selection/ValidatorSelection.t.sol +++ b/l1-contracts/test/validator-selection/ValidatorSelection.t.sol @@ -745,6 +745,8 @@ contract ValidatorSelectionTest is ValidatorSelectionTestBase { previousArchive: parentCheckpointLog.archive, endArchive: endFull.checkpoint.archive, outHash: endFull.checkpoint.header.outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, proverId: prover }); diff --git a/l1-contracts/test/validator-selection/tmnt207.t.sol b/l1-contracts/test/validator-selection/tmnt207.t.sol index 89bd948f5541..85a34b8f84a1 100644 --- a/l1-contracts/test/validator-selection/tmnt207.t.sol +++ b/l1-contracts/test/validator-selection/tmnt207.t.sol @@ -230,6 +230,8 @@ contract Tmnt207Test is RollupBase { previousArchive: rollup.getCheckpoint(0).archive, endArchive: rollup.getCheckpoint(1).archive, outHash: rollup.getCheckpoint(1).outHash, + previousInboxRollingHash: 0, + endInboxRollingHash: 0, proverId: address(0) }), headers: headers, diff --git a/noir-projects/noir-protocol-circuits/Nargo.template.toml b/noir-projects/noir-protocol-circuits/Nargo.template.toml index 17a33b4a805f..bed788a6a6af 100644 --- a/noir-projects/noir-protocol-circuits/Nargo.template.toml +++ b/noir-projects/noir-protocol-circuits/Nargo.template.toml @@ -8,8 +8,9 @@ members = [ "crates/types", "crates/protocol-test-utils", "crates/blob", - "crates/parity-base", - "crates/parity-root", + "crates/inbox-parity-64", + "crates/inbox-parity-256", + "crates/inbox-parity-1024", "crates/private-kernel-lib", "crates/private-kernel-init", "crates/private-kernel-init-2", @@ -47,6 +48,7 @@ members = [ "crates/rollup-block-root-first-single-tx", "crates/rollup-block-root-first-single-tx-simulated", "crates/rollup-block-root-first-empty-tx", + "crates/rollup-block-root-msgs-only", "crates/rollup-block-merge", "crates/rollup-checkpoint-root", "crates/rollup-checkpoint-root-simulated", diff --git a/noir-projects/noir-protocol-circuits/crates/inbox-parity-1024/Nargo.toml b/noir-projects/noir-protocol-circuits/crates/inbox-parity-1024/Nargo.toml new file mode 100644 index 000000000000..0186b566d843 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/inbox-parity-1024/Nargo.toml @@ -0,0 +1,8 @@ +[package] +name = "inbox_parity_1024" +type = "bin" +authors = [""] +compiler_version = ">=0.18.0" + +[dependencies] +rollup_lib = { path = "../rollup-lib" } diff --git a/noir-projects/noir-protocol-circuits/crates/inbox-parity-1024/src/main.nr b/noir-projects/noir-protocol-circuits/crates/inbox-parity-1024/src/main.nr new file mode 100644 index 000000000000..4ab29c082f3e --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/inbox-parity-1024/src/main.nr @@ -0,0 +1,5 @@ +use rollup_lib::parity::{inbox_parity, InboxParityPrivateInputs, ParityPublicInputs}; + +fn main(inputs: InboxParityPrivateInputs<1024>) -> pub ParityPublicInputs { + inbox_parity::execute(inputs) +} diff --git a/noir-projects/noir-protocol-circuits/crates/parity-root/Nargo.toml b/noir-projects/noir-protocol-circuits/crates/inbox-parity-256/Nargo.toml similarity index 82% rename from noir-projects/noir-protocol-circuits/crates/parity-root/Nargo.toml rename to noir-projects/noir-protocol-circuits/crates/inbox-parity-256/Nargo.toml index 5ed4b0ad0143..02a1149ed59a 100644 --- a/noir-projects/noir-protocol-circuits/crates/parity-root/Nargo.toml +++ b/noir-projects/noir-protocol-circuits/crates/inbox-parity-256/Nargo.toml @@ -1,5 +1,5 @@ [package] -name = "parity_root" +name = "inbox_parity_256" type = "bin" authors = [""] compiler_version = ">=0.18.0" diff --git a/noir-projects/noir-protocol-circuits/crates/inbox-parity-256/src/main.nr b/noir-projects/noir-protocol-circuits/crates/inbox-parity-256/src/main.nr new file mode 100644 index 000000000000..a9d07fab4cb8 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/inbox-parity-256/src/main.nr @@ -0,0 +1,5 @@ +use rollup_lib::parity::{inbox_parity, InboxParityPrivateInputs, ParityPublicInputs}; + +fn main(inputs: InboxParityPrivateInputs<256>) -> pub ParityPublicInputs { + inbox_parity::execute(inputs) +} diff --git a/noir-projects/noir-protocol-circuits/crates/parity-base/Nargo.toml b/noir-projects/noir-protocol-circuits/crates/inbox-parity-64/Nargo.toml similarity index 83% rename from noir-projects/noir-protocol-circuits/crates/parity-base/Nargo.toml rename to noir-projects/noir-protocol-circuits/crates/inbox-parity-64/Nargo.toml index 8ca6ed0f8a73..f15275a8050a 100644 --- a/noir-projects/noir-protocol-circuits/crates/parity-base/Nargo.toml +++ b/noir-projects/noir-protocol-circuits/crates/inbox-parity-64/Nargo.toml @@ -1,5 +1,5 @@ [package] -name = "parity_base" +name = "inbox_parity_64" type = "bin" authors = [""] compiler_version = ">=0.18.0" diff --git a/noir-projects/noir-protocol-circuits/crates/inbox-parity-64/src/main.nr b/noir-projects/noir-protocol-circuits/crates/inbox-parity-64/src/main.nr new file mode 100644 index 000000000000..437cadc80912 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/inbox-parity-64/src/main.nr @@ -0,0 +1,5 @@ +use rollup_lib::parity::{inbox_parity, InboxParityPrivateInputs, ParityPublicInputs}; + +fn main(inputs: InboxParityPrivateInputs<64>) -> pub ParityPublicInputs { + inbox_parity::execute(inputs) +} diff --git a/noir-projects/noir-protocol-circuits/crates/parity-base/src/main.nr b/noir-projects/noir-protocol-circuits/crates/parity-base/src/main.nr deleted file mode 100644 index f0e7e161db8d..000000000000 --- a/noir-projects/noir-protocol-circuits/crates/parity-base/src/main.nr +++ /dev/null @@ -1,5 +0,0 @@ -use rollup_lib::parity::{parity_base, ParityBasePrivateInputs, ParityPublicInputs}; - -fn main(inputs: ParityBasePrivateInputs) -> pub ParityPublicInputs { - parity_base::execute(inputs) -} diff --git a/noir-projects/noir-protocol-circuits/crates/parity-root/src/main.nr b/noir-projects/noir-protocol-circuits/crates/parity-root/src/main.nr deleted file mode 100644 index 3cdbf50eb41f..000000000000 --- a/noir-projects/noir-protocol-circuits/crates/parity-root/src/main.nr +++ /dev/null @@ -1,5 +0,0 @@ -use rollup_lib::parity::{parity_root, ParityPublicInputs, ParityRootPrivateInputs}; - -fn main(inputs: ParityRootPrivateInputs) -> pub ParityPublicInputs { - parity_root::execute(inputs) -} diff --git a/noir-projects/noir-protocol-circuits/crates/protocol-test-utils/src/fixtures/vk_tree.nr b/noir-projects/noir-protocol-circuits/crates/protocol-test-utils/src/fixtures/vk_tree.nr index 7c511b3d8ae4..34a8dc0f2168 100644 --- a/noir-projects/noir-protocol-circuits/crates/protocol-test-utils/src/fixtures/vk_tree.nr +++ b/noir-projects/noir-protocol-circuits/crates/protocol-test-utils/src/fixtures/vk_tree.nr @@ -1,8 +1,10 @@ use crate::utils::pad_end; use types::{ constants::{ - HIDING_KERNEL_TO_PUBLIC_VK_INDEX, MEGA_KERNEL_VK_LENGTH_IN_FIELDS, PARITY_BASE_VK_INDEX, - PARITY_ROOT_VK_INDEX, PRIVATE_KERNEL_INIT_2_VK_INDEX, PRIVATE_KERNEL_INIT_3_VK_INDEX, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, HIDING_KERNEL_TO_PUBLIC_VK_INDEX, + INBOX_PARITY_1024_VK_INDEX, INBOX_PARITY_256_VK_INDEX, INBOX_PARITY_64_VK_INDEX, + MEGA_KERNEL_VK_LENGTH_IN_FIELDS, PRIVATE_KERNEL_INIT_2_VK_INDEX, + PRIVATE_KERNEL_INIT_3_VK_INDEX, PRIVATE_KERNEL_INIT_4_VK_INDEX, PRIVATE_KERNEL_INIT_5_VK_INDEX, PRIVATE_KERNEL_INNER_2_VK_INDEX, PRIVATE_KERNEL_INNER_3_VK_INDEX, PRIVATE_KERNEL_INNER_4_VK_INDEX, PRIVATE_KERNEL_INNER_5_VK_INDEX, @@ -69,15 +71,22 @@ pub global VK_MERKLE_TREE: MerkleTree = { leaves[PRIVATE_KERNEL_INNER_5_VK_INDEX] = generate_fake_chonk_vk_for_index(PRIVATE_KERNEL_INNER_5_VK_INDEX).hash; + // The message-only block root lives past the reset-variant range, so it's not covered by the rollup-honk loop below. + leaves[BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX] = + generate_fake_rollup_honk_vk_for_index(BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX).hash; + // Rollup Honk for i in HIDING_KERNEL_TO_PUBLIC_VK_INDEX + 1..PRIVATE_KERNEL_RESET_VK_INDEX { leaves[i] = generate_fake_rollup_honk_vk_for_index(i).hash; } // Honk - // Override some of the above with Honk Vks. - leaves[PARITY_BASE_VK_INDEX] = generate_fake_honk_vk_for_index(PARITY_BASE_VK_INDEX).hash; - leaves[PARITY_ROOT_VK_INDEX] = generate_fake_honk_vk_for_index(PARITY_ROOT_VK_INDEX).hash; + // The inbox parity ladder circuits are plain UltraHonk (not rollup-honk) and live past the reset range. + leaves[INBOX_PARITY_64_VK_INDEX] = generate_fake_honk_vk_for_index(INBOX_PARITY_64_VK_INDEX).hash; + leaves[INBOX_PARITY_256_VK_INDEX] = + generate_fake_honk_vk_for_index(INBOX_PARITY_256_VK_INDEX).hash; + leaves[INBOX_PARITY_1024_VK_INDEX] = + generate_fake_honk_vk_for_index(INBOX_PARITY_1024_VK_INDEX).hash; leaves[ROOT_ROLLUP_VK_INDEX] = generate_fake_honk_vk_for_index(ROOT_ROLLUP_VK_INDEX).hash; MerkleTree::new(leaves) diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-merge/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-merge/Prover.toml index 8ee6d1ad2363..8be53ee24705 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-block-merge/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-merge/Prover.toml @@ -484,17 +484,17 @@ proof = [ [inputs.previous_rollups.public_inputs] timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186" - block_headers_hash = "0x2ff8cd98ff5236e0b4da99b109c2b3d39850c2efd663bf50f63f9e39c7f4389e" - in_hash = "0x00b0e02949c7c042e780651385688dcec114af3dbb3892bab1a9cd8e2bbafdc5" - out_hash = "0x0018febbd74d861e38064a4ff9d3b5ed7a39b398576ef75e104848700819a700" + block_headers_hash = "0x1c433bd51797f9d6090b6acd3df6cca8d0b1a7dbb4cf167a4fe312eb1283262f" + is_first_block = true + out_hash = "0x006bd7618b0cf7b40e3f107022eee2d411bcc5850fbb774dacc46a15957659c4" accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" - accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000" + accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0" [inputs.previous_rollups.public_inputs.constants] chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" version = "0x0000000000000000000000000000000000000000000000000000000000000000" - vk_tree_root = "0x11065543c9a42eac842466277ee9149b27403e398e94c6bba4f525931a2ac6bc" - protocol_contracts_hash = "0x24b2bd6e0456d2d2e64beb505010896a57017c6dedf7516d314d551720c3e6b4" + vk_tree_root = "0x21cd94941458effa5bf748eb3839418d3deb6bdcd2c04148ca733561265326a5" + protocol_contracts_hash = "0x0a1f22b72996215e178699fff463a6ca5e3c7d5ffe66e183490eb766ec1c83ae" prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f" @@ -513,7 +513,7 @@ proof = [ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [inputs.previous_rollups.public_inputs.new_archive] - root = "0x2ec9fc22ae7001e2ada488cbd0ea07e1cf7f54e151dc2bb766e561636b02eece" + root = "0x189ad25ea09777fb1b3d798259ce6a871022d8ff9f0ee907defe19a196ef7319" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [inputs.previous_rollups.public_inputs.start_state.l1_to_l2_message_tree] @@ -533,20 +533,20 @@ root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.end_state.l1_to_l2_message_tree] -root = "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" +root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.end_state.partial.note_hash_tree] -root = "0x24543462563d01f3fa7d2995feb0568f0868807616f9135cbcec47610a688576" +root = "0x01612d24a146efc2df9d815a2f733c17486304424577ffb4232fe4cb0c94e1e7" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000040" [inputs.previous_rollups.public_inputs.end_state.partial.nullifier_tree] -root = "0x0d5183688b388e23b4fe243d466e4d50acaf63d7afa00ca046fe2bf2e83db99d" +root = "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684" next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" [inputs.previous_rollups.public_inputs.end_state.partial.public_data_tree] -root = "0x27b8cdfd5211a289e0aa40da120fa969649354b3a0084d32d1ba1aca6b16f5b9" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.start_sponge_blob] num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -567,88 +567,164 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 squeeze_mode = false [inputs.previous_rollups.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000552" + num_absorbed_fields = "0x00000000000000000000000000000000000000000000000000000000000004d4" [inputs.previous_rollups.public_inputs.end_sponge_blob.sponge] cache = [ - "0x0d5183688b388e23b4fe243d466e4d50acaf63d7afa00ca046fe2bf2e83db99d", - "0x27b8cdfd5211a289e0aa40da120fa969649354b3a0084d32d1ba1aca6b16f5b9", - "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" + "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684", + "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9", + "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" ] state = [ - "0x0e2949060fe0f2aa67a11a1f8c7449f74124ab122ca0bfcc6d1dc19dde1e5268", - "0x06620ebc6d7abb78fe8de2f9f66c4cabbe323d277ef8de952dd1b59cd36bee17", - "0x129daea73c37f015b42271c76bad72aadcb53b8a12b8fb40b708f528315f16a8", - "0x0bfe4f9fb5d9e711aff1b1f4c96be770b3717443ed65ea7907957428c2f24702" + "0x009f1dc03d403fc57f6a7b5f0ea9fb5d6006f33f7dfa1ee07ba476c8cb9aa149", + "0x03eac050066cd97802cbfe21494b799f839c413f9201cd69565a0b51fdedf9a4", + "0x0ada419854665bbe9ac7531f0452151d715642b83fa706238ef4e8c13b5ebba1", + "0x07b55e74b45433061f40fa1fefcf710b910ac2ed7ad0bf25de1141977632097a" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000003" squeeze_mode = false + [inputs.previous_rollups.public_inputs.start_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.previous_rollups.public_inputs.start_msg_sponge.sponge] + cache = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + state = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000000" + squeeze_mode = false + + [inputs.previous_rollups.public_inputs.end_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.previous_rollups.public_inputs.end_msg_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" +] + state = [ + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false + [inputs.previous_rollups.vk_data] leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000b" sibling_path = [ - "0x22f4e6497a7b25cb4baa538d7485c88094a612f07795194d171fa482dd7d50cd", - "0x14006eaa287c9ad153160a93307e789266c077e1c656dba37a430d1a966bfc4f", - "0x18b9d1703288fad007e0e97212dedf18305ab172790fe8d5c7aeea5c2634673b", - "0x0481dbd69f3e084904030eb9771134ae7be848ec7b4af69e75933270ceeb544d", - "0x1fe698f1a6368c855525a9abcc3713bb49b1dec627f796bf4e23cc86473621ec", - "0x1c7b07f7b3f8344fece2e6a10bc9480dc4b90f89d2a51f344bee80ca5a4bda6e", - "0x12ed8e93726f8b5b79d1291566a72c1775861d60bba2daa19edb3f28d0ae7a3e" + "0x0bfffaacc0ace22638ea88b1222faf3cdc201fe0b8a9be25c963a8a8558af231", + "0x2bcbfd2ace3467d92572d8c6f115a6f14527c97c7a0e1a08d20ca37c956dc021", + "0x1aa2c311f1d6eea148dd66af34720e2fe4ba1da63ff651b63936c6bc06d426bf", + "0x2d425e446b233c409ab688f27e6a8d41e20b06b8b769f68be61d032ba6cba44a", + "0x1a713453d218bb2fc34986e0392f018dc66cd5828df84413c10055d3c4ad7d24", + "0x187a7b8872d1297bc15f7171f32c36e5e60b53c4145ef62b1899c04fd7220fdf", + "0x2ccaede67145021b6b586f45936dfbdacb151c3e362621c3598ffd60e95b02a0" ] [inputs.previous_rollups.vk_data.vk] key = [ - "0x0000000000000000000000000000000000000000000000000000000000000015", - "0x0000000000000000000000000000000000000000000000000000000000000046", + "0x0000000000000000000000000000000000000000000000000000000000000014", + "0x000000000000000000000000000000000000000000000000000000000000005a", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x000000000000000000000000000000aee5a6496fa3a661700c83acd517281844", - "0x00000000000000000000000000000000001c11e90eb2e15ecb7f1ba74a9e724c", - "0x0000000000000000000000000000004b67867b7c12f4d25dd039ea4b65e20a6a", - "0x0000000000000000000000000000000000155c9172c95566dd1c8b452ef68e22", - "0x000000000000000000000000000000ab4c33bf6a832e7630320a1aebd3a0a92e", - "0x000000000000000000000000000000000013ce11b3674d67e72f0f9ab13884e1", - "0x0000000000000000000000000000009ba8a4d221cf75901708c65b3bf697ef05", - "0x00000000000000000000000000000000002a1c7e0ffd43eb569f294936abd107", - "0x00000000000000000000000000000027fae31667436475ebda753a1707bb43e1", - "0x00000000000000000000000000000000002188318688f9d6076c39a76936e736", - "0x000000000000000000000000000000f07f330468b108c481a0360c6530436b9e", - "0x00000000000000000000000000000000000927e0cf9230ff9f85ffc2dc29c577", - "0x000000000000000000000000000000db572957a679dfa7233087e335184be5c0", - "0x0000000000000000000000000000000000193e2223973bb9e17b46bfb526226e", - "0x00000000000000000000000000000057881e47be28987fed5fb648b6a920ada4", - "0x00000000000000000000000000000000002ac4687d1af85a3985a58fbbf0df68", - "0x000000000000000000000000000000e3c9ae330392908131edeb2060b0c3a770", - "0x00000000000000000000000000000000002dce10f29bad8d706af353a9e3f1fe", - "0x00000000000000000000000000000068c345af3c51001882c5b4a4313a0c6e47", - "0x00000000000000000000000000000000000edf3e1c9e89dd449c894d6cd3c53e", - "0x00000000000000000000000000000087b408c013e09c4fa25fead652a828415a", - "0x0000000000000000000000000000000000120e1e724dccd2546cebeb9c541068", - "0x0000000000000000000000000000006631372634c9f7022dacf4e4e0ac76f32f", - "0x00000000000000000000000000000000000bd9710830435bbf46b22522f07598", - "0x0000000000000000000000000000001058263227d31b4cc3dacdb2cb4aabe92c", - "0x000000000000000000000000000000000025ceb14bcba3643bfbfa01be6bdb05", - "0x000000000000000000000000000000fcf6e6eccb38071546ccd021686fdf17e4", - "0x00000000000000000000000000000000001a820777e0253b1c6b3c595b887ed1", - "0x00000000000000000000000000000068469d53e72f55318a25e47b4cf13e2d6b", - "0x00000000000000000000000000000000002ee8d23d41c9b8afe617964a273a30", - "0x000000000000000000000000000000ef5ac6a00417869ecca8f41b9142e343e7", - "0x0000000000000000000000000000000000241c88aa98ad8cde8c010c8baf65d1", - "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", - "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", - "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", - "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x00000000000000000000000000000054d6eae72b14fc4dde2071b7056010e6b1", - "0x00000000000000000000000000000000002b35ea76bd0402a8617a0903dd6cbc", - "0x000000000000000000000000000000b65b0dac635188f8bb81647d0a1f8ca151", - "0x0000000000000000000000000000000000223f7db48b4fca146caa761dbb3c94", + "0x00000000000000000000000000000016870146d3593ef8d476311bf4ae40b3fe", + "0x0000000000000000000000000000000000248f678407d9b172e57c6ced583661", + "0x0000000000000000000000000000006a394101b53042500c4860f6313042fae8", + "0x0000000000000000000000000000000000030710ec7b577127bd943704d42f6a", + "0x000000000000000000000000000000f43a6398c0a7d850143e1d6662d6f65bdc", + "0x000000000000000000000000000000000028dd503fbd9e4252452934012d0cd1", + "0x0000000000000000000000000000009ecc8b1f4f2d2223033e133fc151fd0bd7", + "0x0000000000000000000000000000000000060f78af9fa55ce5a14187d9d7683e", + "0x0000000000000000000000000000009bd3ee7b0bc900dc71bcb732e3aa304e69", + "0x00000000000000000000000000000000001e33208e819fda451b7f13a3c85197", + "0x0000000000000000000000000000007bebac10672d37da52903e5abd8d267dd3", + "0x000000000000000000000000000000000003e17e3b3e3286f0e238b33f1c345e", + "0x00000000000000000000000000000034a228a47f746555beb46e591cd143153c", + "0x00000000000000000000000000000000001c2dbd8081682097732aa4a60159a3", + "0x000000000000000000000000000000215bb0e0c9c342f05492d3cfe653299667", + "0x000000000000000000000000000000000026cc0faf9a2bd13913d3ab61715ea7", + "0x000000000000000000000000000000fac3716fdf748e06318554bd1f668eede7", + "0x000000000000000000000000000000000013bbd4b9d06db70c77b598a3412c35", + "0x000000000000000000000000000000ca3f0d346647a9122f210e6850e1c4e066", + "0x0000000000000000000000000000000000278a0dcf77edea892248ea5e7e0ded", + "0x000000000000000000000000000000313593fd17c4872ad078ad6f9e34852fcf", + "0x000000000000000000000000000000000017b917ed21479ce25d74d00cc3c0c6", + "0x00000000000000000000000000000001a70ea1b0c4178ec0fd26c59f77eb2cb4", + "0x00000000000000000000000000000000002c1844e6ad54a26c3490510f94da9c", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000000000fd04bd390f29d7adc81dc7ea3a27eed449", + "0x000000000000000000000000000000000017c9c75b32751bf47fa68ea94e478c", + "0x000000000000000000000000000000efe7853c899f1c4b9d6e29192e39fa5a13", + "0x000000000000000000000000000000000014ef034c87585e76ee7b3c4f12cc8a", + "0x000000000000000000000000000000175a5234d2daf07d78fc6e8ca99e33c998", + "0x0000000000000000000000000000000000187c296f22128ad422efd8d3288b23", + "0x00000000000000000000000000000082ef1103acb273b304cd7e123f05cf6f7d", + "0x00000000000000000000000000000000001eb1b4083950ad9dd775dc50b05aa8", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000000000d8ed08c86e63ca304b38c50eca6d6b1b03", + "0x000000000000000000000000000000000016bd1b8423f3838a13abed1938e06f", + "0x000000000000000000000000000000f1e66bec1c72f2a1b85efc4b149d76cbc7", + "0x00000000000000000000000000000000000102ad1b98f28ca9acb62eced68e2f", + "0x000000000000000000000000000000317cb5f505426e1caf7818bcc07faa398e", + "0x00000000000000000000000000000000001bc3bffa73c96c51f98ce11500aa8a", + "0x000000000000000000000000000000a92132f7a15dcacc4ca2d9c7ecc69696b2", + "0x000000000000000000000000000000000008aeb6319d17f2ace474a2e3d551d0", + "0x0000000000000000000000000000006c54fd59f107a1291691bc0617c52a6a69", + "0x00000000000000000000000000000000002d15cd28473d4abde07170b4529b2a", + "0x0000000000000000000000000000008382ed0448234cc9731618ae09c80ec2c0", + "0x000000000000000000000000000000000015a11505cc675fe1d98f16a06a71a2", + "0x000000000000000000000000000000efb5ea6f3f24d4d17b82a3b989e1fc57db", + "0x0000000000000000000000000000000000031d94ec5f2f138bd215a5a4f510c0", + "0x000000000000000000000000000000c778fc5eafc4cd69732fa8c45c1829f5e0", + "0x0000000000000000000000000000000000085536edc0f08144d43f9cacc09fee", + "0x0000000000000000000000000000002f3b37a09d8a2908a2d436f67be0771e39", + "0x00000000000000000000000000000000002638f71d0b9deb8bc009872795e12f", + "0x00000000000000000000000000000074e112f4d5888fd21d8ae34288725f505d", + "0x00000000000000000000000000000000001b8c50b746db2b8db0a104fa6161e1", + "0x000000000000000000000000000000a9eb9ae956b8a0250d4e7705a8d1a62003", + "0x00000000000000000000000000000000002d9d1ace4b8a3677647468ee815a89", + "0x0000000000000000000000000000008ff2bcc202ecd0b4bb9526aace8eaa1359", + "0x000000000000000000000000000000000011696efadbcb7eeb719c8d343cce65", + "0x0000000000000000000000000000001e868da74428861d67d180d07c0cd5c399", + "0x00000000000000000000000000000000000305d024968c118f2b46c600432cdd", + "0x00000000000000000000000000000046106c6ed5d69ee4fb94e464b9f1a1b845", + "0x00000000000000000000000000000000000fae25945aead7144dcddd1501bcc1", + "0x00000000000000000000000000000063e30460f272c6aec1799b5cda67e61a97", + "0x000000000000000000000000000000000020d06d6d7f6223f2d1eac16ba32154", + "0x000000000000000000000000000000b94510f693cb06734a6c880684d68b8cbf", + "0x0000000000000000000000000000000000214f711f584ffb20ed72c41c280507", + "0x0000000000000000000000000000004c84bbfdc6382c65d2be30aa007df07af1", + "0x000000000000000000000000000000000023d97d8f22f4546f478f27653f47a3", + "0x000000000000000000000000000000f5be1538b9ad02838a317bb0a853b0c34c", + "0x0000000000000000000000000000000000296d572c53b5e195a475469e83f354", + "0x000000000000000000000000000000c12ded8ff899229c007bd33390644c901f", + "0x00000000000000000000000000000000000f76f9606f6f0fdeb027a16816e2f8", + "0x000000000000000000000000000000b8d7f7036a21c07399991386406846f992", + "0x00000000000000000000000000000000000173d5d6ef179108107ae9879a7029", + "0x00000000000000000000000000000027b3d25860f97c748d4728021e81f21db3", + "0x000000000000000000000000000000000026bb2a90e1cefe6f7a721e98333d85", + "0x00000000000000000000000000000077d5f85b3ef41c91c1282c2cd5bf316dd3", + "0x00000000000000000000000000000000001ac5ef90fcb7749aa3d09f355cdd21", + "0x00000000000000000000000000000006117e5bf7c31f42b7faec18e68fd51880", + "0x00000000000000000000000000000000002fc4fbc2da3cea4708d40b54aab3b5", + "0x000000000000000000000000000000040a49d9d79c0ab52a53563426502d7423", + "0x00000000000000000000000000000000000c6df35c6df6f0adcbd048d89d359a", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -661,60 +737,20 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x000000000000000000000000000000075bb41cafcfe782f8df8a2e4cdd8d5392", - "0x000000000000000000000000000000000025beb638ee1aa3023eaeb0037db6bf", - "0x000000000000000000000000000000536131ae5a40f7ed22751054b75a27e259", - "0x00000000000000000000000000000000002c0857f9472e89fed30cf9f7554904", - "0x00000000000000000000000000000025566cbef76bf6deca97778e208b16128b", - "0x00000000000000000000000000000000002052141e0934e9ac5e3d25f0a5f13b", - "0x000000000000000000000000000000ea0eeaa5c6d8910591d876d099e02d8e09", - "0x000000000000000000000000000000000026d4c9e0cec52ec9b6fd4268dbd17b", - "0x000000000000000000000000000000fc0ac2ac970971a77b9f335947c41b19b7", - "0x0000000000000000000000000000000000094991889e0ee754f762f24a72f5a9", - "0x0000000000000000000000000000002985e3a4f79e8a589da09b6630f5c58eae", - "0x0000000000000000000000000000000000227bb2abbecc90484ed52967233eb7", - "0x00000000000000000000000000000033692154a048cdd9ba831328975c8d3feb", - "0x00000000000000000000000000000000001b1afa6ec22c2121b14f2add6c229b", - "0x00000000000000000000000000000054869872b138fbcee2ce101617e0728be1", - "0x000000000000000000000000000000000023c613e3289ce2b5dbe02fd14007a7", - "0x000000000000000000000000000000a69f691a705d9913032652dfb1f8a45315", - "0x000000000000000000000000000000000003e86f111b8b64338847a1bcb5da23", - "0x000000000000000000000000000000d45e898c6c39b38f7159c2c19996ffc7d2", - "0x00000000000000000000000000000000000b492395dfb30d2d58f1b351322451", - "0x000000000000000000000000000000f7c224482b327308e4096909073465ad4b", - "0x00000000000000000000000000000000000f8ef4d1e3565050a007be36575fdf", - "0x0000000000000000000000000000009742cd64032a8809b9ffb80dafa618f515", - "0x00000000000000000000000000000000002e6e9a9301fc2f98b875dc38042163", - "0x0000000000000000000000000000003c7355558cce2984b65e1b57e3d3343d98", - "0x000000000000000000000000000000000026e8d11386fe0c0b86d1024636c4a9", - "0x000000000000000000000000000000f0c7e6fac74cbb2607023ba61d8a94b49b", - "0x000000000000000000000000000000000019a32ca8eb2427c10358ffb0597f44", - "0x0000000000000000000000000000002a6c50c2559db69dcac9c03c33cf20519a", - "0x0000000000000000000000000000000000295c503b2caa82d1f0f81507233e0f", - "0x00000000000000000000000000000047cf9e2fee1fa0b1707a62198b29e2b92c", - "0x00000000000000000000000000000000001ed99f7a731f120fed39f23a249979", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000008311045d79f1af4e6ab4da30950dbda122", - "0x00000000000000000000000000000000001f5225293633b8dcf201a35833ab9f", - "0x000000000000000000000000000000de8cf54bf8761134b2727a783c47fa7caa", - "0x0000000000000000000000000000000000100902da337b6f1c4d4cb136742807", - "0x000000000000000000000000000000f3f72d81f9e9005b37f61a42cc134a059e", - "0x00000000000000000000000000000000001a8c13fc64e5ea813c4f2aac247704", - "0x000000000000000000000000000000e4a50df20cc397bad7b16b984049c0e4e8", - "0x0000000000000000000000000000000000276278012ea0a3d68b2e86592425d7", - "0x000000000000000000000000000000040337ca657bec2011d89bfcbe67fce8f3", - "0x00000000000000000000000000000000001aa81ac813877b8530b548b34a519b", - "0x000000000000000000000000000000273b87fe7d60adfe7718ce2d7cd92dba00", - "0x00000000000000000000000000000000001c0838e71383534ed742e8e6b96795", - "0x00000000000000000000000000000028de0c0f13a7f95474e891a50d39992da1", - "0x00000000000000000000000000000000000a6aa94a1643918ec7010295f9c54a", - "0x00000000000000000000000000000016dd915dc0c3f4af8520cb7fbebbe39c3a", - "0x000000000000000000000000000000000025a1c2d5387b9a26ed012a0a12b95f" + "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", + "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", + "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", + "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", + "0x0000000000000000000000000000001fc1b1f6b42bbff1b22d446c518914bef1", + "0x000000000000000000000000000000000008a01262b4297b882e1eb736f9468c", + "0x000000000000000000000000000000d9249f4b3bcecf1f9e13cfbaa3c35ca6b9", + "0x00000000000000000000000000000000000eef5aa23e599d33103603e39f0726" ] - hash = "0x21e596b78e2d114b02fc7196c6899097a27c84e90b5fe3f5f38bdfd9dee10369" + hash = "0x2ce400d5cea2dc3231b12ddf2e90aa9df5994e656b5c607a1766e18c88981791" [[inputs.previous_rollups]] proof = [ @@ -1202,8 +1238,8 @@ proof = [ [inputs.previous_rollups.public_inputs] timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186" - block_headers_hash = "0x144a37283715921f3d25fa41b95ed787b28fe418ff6c384c1a350e4815c823cc" - in_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" + block_headers_hash = "0x2e2506e1f7c884bae4b66962d05617165f7bbdb1271abcce8f6c76855e3b322c" + is_first_block = false out_hash = "0x00abb50b8989a7f19fd4526d43e15a1ab5d2a43af413cc8ca91e82a3c8828625" accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -1211,8 +1247,8 @@ proof = [ [inputs.previous_rollups.public_inputs.constants] chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" version = "0x0000000000000000000000000000000000000000000000000000000000000000" - vk_tree_root = "0x11065543c9a42eac842466277ee9149b27403e398e94c6bba4f525931a2ac6bc" - protocol_contracts_hash = "0x24b2bd6e0456d2d2e64beb505010896a57017c6dedf7516d314d551720c3e6b4" + vk_tree_root = "0x21cd94941458effa5bf748eb3839418d3deb6bdcd2c04148ca733561265326a5" + protocol_contracts_hash = "0x0a1f22b72996215e178699fff463a6ca5e3c7d5ffe66e183490eb766ec1c83ae" prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f" @@ -1227,146 +1263,222 @@ proof = [ fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.previous_archive] - root = "0x2ec9fc22ae7001e2ada488cbd0ea07e1cf7f54e151dc2bb766e561636b02eece" + root = "0x189ad25ea09777fb1b3d798259ce6a871022d8ff9f0ee907defe19a196ef7319" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [inputs.previous_rollups.public_inputs.new_archive] - root = "0x02c1e55021910a8552fe034bd1dad5769dec59fc837d88b03d9cf7a8bba0a348" + root = "0x25d517225f0f8bd739dd1fda514be0d6e6566c091b69c067ae0a339b586f87ca" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000003" [inputs.previous_rollups.public_inputs.start_state.l1_to_l2_message_tree] -root = "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" +root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.start_state.partial.note_hash_tree] -root = "0x24543462563d01f3fa7d2995feb0568f0868807616f9135cbcec47610a688576" +root = "0x01612d24a146efc2df9d815a2f733c17486304424577ffb4232fe4cb0c94e1e7" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000040" [inputs.previous_rollups.public_inputs.start_state.partial.nullifier_tree] -root = "0x0d5183688b388e23b4fe243d466e4d50acaf63d7afa00ca046fe2bf2e83db99d" +root = "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684" next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" [inputs.previous_rollups.public_inputs.start_state.partial.public_data_tree] -root = "0x27b8cdfd5211a289e0aa40da120fa969649354b3a0084d32d1ba1aca6b16f5b9" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.end_state.l1_to_l2_message_tree] -root = "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" +root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.end_state.partial.note_hash_tree] -root = "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449" +root = "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.end_state.partial.nullifier_tree] -root = "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8" +root = "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" [inputs.previous_rollups.public_inputs.end_state.partial.public_data_tree] -root = "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000fe" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollups.public_inputs.start_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000552" + num_absorbed_fields = "0x00000000000000000000000000000000000000000000000000000000000004d4" [inputs.previous_rollups.public_inputs.start_sponge_blob.sponge] cache = [ - "0x0d5183688b388e23b4fe243d466e4d50acaf63d7afa00ca046fe2bf2e83db99d", - "0x27b8cdfd5211a289e0aa40da120fa969649354b3a0084d32d1ba1aca6b16f5b9", - "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" + "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684", + "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9", + "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" ] state = [ - "0x0e2949060fe0f2aa67a11a1f8c7449f74124ab122ca0bfcc6d1dc19dde1e5268", - "0x06620ebc6d7abb78fe8de2f9f66c4cabbe323d277ef8de952dd1b59cd36bee17", - "0x129daea73c37f015b42271c76bad72aadcb53b8a12b8fb40b708f528315f16a8", - "0x0bfe4f9fb5d9e711aff1b1f4c96be770b3717443ed65ea7907957428c2f24702" + "0x009f1dc03d403fc57f6a7b5f0ea9fb5d6006f33f7dfa1ee07ba476c8cb9aa149", + "0x03eac050066cd97802cbfe21494b799f839c413f9201cd69565a0b51fdedf9a4", + "0x0ada419854665bbe9ac7531f0452151d715642b83fa706238ef4e8c13b5ebba1", + "0x07b55e74b45433061f40fa1fefcf710b910ac2ed7ad0bf25de1141977632097a" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000003" squeeze_mode = false [inputs.previous_rollups.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000aa3" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a25" [inputs.previous_rollups.public_inputs.end_sponge_blob.sponge] cache = [ - "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8", - "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f", - "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449" + "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00", + "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759", + "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" ] state = [ - "0x15da51316f6d05717039ebdac951746a67f2039305acba3dde6937f37537a3be", - "0x18d3719d0b48c48b53ca67a10f27a44337f426a5765bad3dacedaacfb6ccac97", - "0x14aff5482ea838000d13644e493656299d3e8d89a40030dbe5ca9bfc7ca80e9b", - "0x101f0785768c74cde83892e08bc25e14d7aff6304b2281bbcdee77377417c602" + "0x20dd63a6579867a60428c48bee502633fa2b8978bb17d6a6b950714505def8a6", + "0x11d5f7cc6c52edc467782a1cbf6f5697662f1afcf75852bfc3b0418ebd03befd", + "0x15fa9fb2deb7229a19d7442b430b65dbc05ccedb42b24232e78453fc9818de78", + "0x2d7cd94b6677cd74ca7a0dacb843fe341b1256caa1f9f778e6a1f5e3049c3959" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" squeeze_mode = false + [inputs.previous_rollups.public_inputs.start_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.previous_rollups.public_inputs.start_msg_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" +] + state = [ + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false + + [inputs.previous_rollups.public_inputs.end_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.previous_rollups.public_inputs.end_msg_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" +] + state = [ + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false + [inputs.previous_rollups.vk_data] leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000e" sibling_path = [ - "0x06b2006cb3575a42771e0becfe866fcfcef2d52af8bc19f613cabdb3122f2dc7", - "0x279cfadc25df7db3e8d0a15e10ff6e5f4bcb741888255ef55ded2c7e7f364ffe", - "0x1944964394682423d7fc879430c65da6feda679bf7aba3c1e99a6cbd464ada9a", - "0x0481dbd69f3e084904030eb9771134ae7be848ec7b4af69e75933270ceeb544d", - "0x1fe698f1a6368c855525a9abcc3713bb49b1dec627f796bf4e23cc86473621ec", - "0x1c7b07f7b3f8344fece2e6a10bc9480dc4b90f89d2a51f344bee80ca5a4bda6e", - "0x12ed8e93726f8b5b79d1291566a72c1775861d60bba2daa19edb3f28d0ae7a3e" + "0x234a1affbbad1ed91d19c156a1213eefd906ba765ff77021fe12993713bd467e", + "0x2c50d94eb3d3c79b66ad48965e0e7f91c1d97d6b80d8d687509ec1f05fd908a7", + "0x02b27c0449df8c15133807ecced497a18bd8da3cdc65a840c68163925e93f908", + "0x2d425e446b233c409ab688f27e6a8d41e20b06b8b769f68be61d032ba6cba44a", + "0x1a713453d218bb2fc34986e0392f018dc66cd5828df84413c10055d3c4ad7d24", + "0x187a7b8872d1297bc15f7171f32c36e5e60b53c4145ef62b1899c04fd7220fdf", + "0x2ccaede67145021b6b586f45936dfbdacb151c3e362621c3598ffd60e95b02a0" ] [inputs.previous_rollups.vk_data.vk] key = [ "0x0000000000000000000000000000000000000000000000000000000000000014", - "0x0000000000000000000000000000000000000000000000000000000000000046", + "0x000000000000000000000000000000000000000000000000000000000000005a", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x000000000000000000000000000000f68447ed8472d9f9aecf573652a9d9a928", - "0x0000000000000000000000000000000000130b78833f316a05f0ac3ebb960dd6", - "0x000000000000000000000000000000b1b7566b1bdad938d7329c4055a9d3b44b", - "0x00000000000000000000000000000000000f95bf795c56af943937121ccabb11", - "0x0000000000000000000000000000007e871cbdb15c3280bb41589af6d4bf4600", - "0x0000000000000000000000000000000000005841a06f458a5220f323f6e67389", - "0x00000000000000000000000000000037a8be1964e1c1bf15fa90bbade2ae533e", - "0x00000000000000000000000000000000002fd8adf54cbe47073d8c68ab7231c7", - "0x0000000000000000000000000000007e2dfa58dd9e40bb6ee06db57e6892ad8e", - "0x0000000000000000000000000000000000228189c3a773ff5454da3c52426f43", - "0x000000000000000000000000000000ce262d6729da8006583c8f4a499313308d", - "0x0000000000000000000000000000000000121dc58a8b11eda0e11e988dc148f3", - "0x000000000000000000000000000000d483c67a2dd422d558a2bc6a0dc65c5441", - "0x00000000000000000000000000000000001436c8685ec282c19bacd9671e3424", - "0x000000000000000000000000000000505cfbf25a6b529a79d93da8a67a535226", - "0x0000000000000000000000000000000000277d585acb24a736a24c1c8715e0aa", - "0x0000000000000000000000000000000f71609653b0671afa25e611656d7024e2", - "0x000000000000000000000000000000000026075d31cd834975ea2ca0b120b383", - "0x000000000000000000000000000000307b6f68e4b5f4b0b1f1c7bf03a5442d7c", - "0x00000000000000000000000000000000001ef258df94844ef33b6ebc66098df9", - "0x000000000000000000000000000000366ab50465812874d088c1c47734295381", - "0x0000000000000000000000000000000000065332753549245a04b0f54d60d47d", - "0x00000000000000000000000000000016902f2c8fd7591bd62d52226e951c25b0", - "0x00000000000000000000000000000000002c90216fa88bb7b51a01c3ef4a320e", - "0x000000000000000000000000000000bbb432c76b363d49388741cd8557e22106", - "0x00000000000000000000000000000000002565b0ddbf8d6afaa067b84cb1f12e", - "0x000000000000000000000000000000974b3ad2190f2582dda8748859d47859a0", - "0x00000000000000000000000000000000000b31cf0fb5ec5e6d8541057aa4e2f2", - "0x000000000000000000000000000000025960f9968c5bbf83d3f7a484672b98d8", - "0x000000000000000000000000000000000013026001fd1b1981ad17e862f15a34", - "0x0000000000000000000000000000006e292910e9382851ed4de1b3ee3474c02c", - "0x00000000000000000000000000000000000c2fb93933722953cc5775728b35ec", - "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", - "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", - "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", - "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x000000000000000000000000000000239e2f11ea91c867d7080a159fc15e5711", - "0x000000000000000000000000000000000020983a3f65fd98715524f3be6a4d48", - "0x0000000000000000000000000000006251dee2124c8e8689c942362741d1b770", - "0x00000000000000000000000000000000002990e25ef65b37a0c14b2a53e370aa", + "0x000000000000000000000000000000ff4574b1227251dfcacb2b1cdeed2603a5", + "0x0000000000000000000000000000000000222f418fed55fe010e2723697e1021", + "0x000000000000000000000000000000254feb031e35bd30fcf3686fd6faddd206", + "0x00000000000000000000000000000000000ba1a34ed5d42f1a21c5a52d9e90c0", + "0x000000000000000000000000000000e118157f90e615e8b4c444cab7c33f6e3c", + "0x00000000000000000000000000000000000afef4eb2cb22347a56993e55469b8", + "0x000000000000000000000000000000a38693cfd4142021710e86c17fdbdcbd69", + "0x00000000000000000000000000000000001dc2b2414aa1381f6ac979a1afbb1d", + "0x000000000000000000000000000000127ad45c1ad20664e3e0a295ffd1ed5c79", + "0x0000000000000000000000000000000000268ff210a6ae44151e22594dfa269e", + "0x0000000000000000000000000000001a584a1a6c51a01d8023f6dfb901b1af2e", + "0x0000000000000000000000000000000000070d0b4337db22fe09dcb1fbf8000d", + "0x000000000000000000000000000000f2a18597020020d2f118b79687921c9828", + "0x00000000000000000000000000000000000764b6bbb22dfead6bd98b038666af", + "0x000000000000000000000000000000a73aa96f7a696edf98e8688f626704d82b", + "0x0000000000000000000000000000000000238a95d5770b7bb0d57f8d8dcf3d50", + "0x000000000000000000000000000000769f6f412b91a402ace2e2ae5c64fdaaea", + "0x00000000000000000000000000000000000729cdc86fd7c2d54d2c005fc8da9c", + "0x0000000000000000000000000000006a87bb25b31e29eca5da23f5bf5b92a7ff", + "0x00000000000000000000000000000000002c51d35e7454a247cb8771c2c3e9fe", + "0x000000000000000000000000000000e30ed03e9911efef084c53f3c35e8f63fc", + "0x0000000000000000000000000000000000171836f4370875467b733b028e3595", + "0x000000000000000000000000000000300ddd2e4fdd5f1a499edcccea116e9805", + "0x000000000000000000000000000000000004c5e1b8266307c27cf24378919ed1", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000000000cd984dac2e1d13365d9b929aa7116a4be3", + "0x0000000000000000000000000000000000024e666f741dd221d25579e5ebedd1", + "0x000000000000000000000000000000a3518dfe05586c1715bd6777c11f1bb094", + "0x00000000000000000000000000000000001c60329dd65cffc68e5ed52a1b8e4c", + "0x000000000000000000000000000000d6e022490802db56aee0ce03b62dbe7558", + "0x0000000000000000000000000000000000004dbb462842fc03bb9207a68909be", + "0x00000000000000000000000000000060f432f86a6e25ef80a1a105d02af8b11a", + "0x00000000000000000000000000000000001576d3165664d2ae2fe124c2fa8c36", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000510359caf6759daa96ba145e49edd7b53", + "0x00000000000000000000000000000000001160ea7e6acd5070159b5a719b68e1", + "0x000000000000000000000000000000870b7ef96e9ed4ed322b357611712f7821", + "0x00000000000000000000000000000000002b61b69da9f3961363a845365d70f0", + "0x0000000000000000000000000000008cbf79e824623353244aab5f790e992f12", + "0x0000000000000000000000000000000000184748bc300b017268945c5b75cb17", + "0x000000000000000000000000000000b10e7398241322d1dc50fcff8fa422cd72", + "0x00000000000000000000000000000000002b2203eece068ca0c3e432e9475bda", + "0x00000000000000000000000000000078b23340284716c316807ce3fbb9381100", + "0x00000000000000000000000000000000000dfcb9fdb059e25709922011e763da", + "0x000000000000000000000000000000682e97a021cf246cb07730c05f115a15f7", + "0x000000000000000000000000000000000006d7f886730d6284ef616e698ce9b5", + "0x000000000000000000000000000000b493b6aeded29ae39a8a8cf37be9b06f56", + "0x000000000000000000000000000000000021debaec4ca18d2e367b7798849c12", + "0x000000000000000000000000000000f0961bb1e9dc4808d5599315aed5e378b3", + "0x00000000000000000000000000000000000480bda077c2dff37f7391769f0b31", + "0x000000000000000000000000000000fe67bca465f478068eee31f7f3040da4dd", + "0x00000000000000000000000000000000001e4616dcaac6ec288998766fdb3bd2", + "0x00000000000000000000000000000079343abbbbd8b68a48f7158d262c5aed34", + "0x000000000000000000000000000000000028c32d2170f9be04a28a9330cf357b", + "0x000000000000000000000000000000b909a149f6c1d43b57f2294a04c06b24ee", + "0x000000000000000000000000000000000006089105f210191e5df1886f1f9302", + "0x0000000000000000000000000000000a2c393d72c6a5eb6cd4eebe4af81047b0", + "0x00000000000000000000000000000000001452dc66f26377684d2cc7659b1aca", + "0x00000000000000000000000000000038a9f03481239a0f43e1d8e857e8b17917", + "0x000000000000000000000000000000000000aaf6e93a230cd6d3d63daf13248b", + "0x0000000000000000000000000000006f6cbbf68fb6d911cd26538f02a788a9ed", + "0x000000000000000000000000000000000008c74d1802b908bba672fb86cdbaff", + "0x00000000000000000000000000000099710cd72aac361ff9ee58bb0da55f0106", + "0x0000000000000000000000000000000000177ad0a12f12c8737ecf44d30560f8", + "0x0000000000000000000000000000009c6f1b7e67171bfdfc00690205dbb8f9a0", + "0x0000000000000000000000000000000000254a0583283aec3b040d48b11449c7", + "0x0000000000000000000000000000001e3d9a29da606e87c2a215e39f0724683b", + "0x000000000000000000000000000000000020e5099d9ca8c722ea29532fcedb55", + "0x000000000000000000000000000000cfd353364f888cf7ee2e46c851ea5fdf1c", + "0x0000000000000000000000000000000000303ff98371cf89a0652970477d717c", + "0x000000000000000000000000000000604d2bbb7678fbd283ee2d1390b71ff74e", + "0x00000000000000000000000000000000001c802555a4fb9d3311ba62e1017301", + "0x000000000000000000000000000000889c5511d7d48961f6d777b2e225cd113b", + "0x0000000000000000000000000000000000219f03b84fae3708a9d0786d093c18", + "0x00000000000000000000000000000036bf2618bd6a98969e5f2d5e3060929112", + "0x000000000000000000000000000000000006b4e85d4be40abd02526a84e5001d", + "0x000000000000000000000000000000eae2fc2f2607048dcedb51ed379eac0b1d", + "0x00000000000000000000000000000000000c64c8a5ee9037024d0b511f97593d", + "0x000000000000000000000000000000788e901ccccc684136577114d7be220c49", + "0x000000000000000000000000000000000008cf820a32310ad229832ed67aeddf", + "0x00000000000000000000000000000099aba7761e71e351671554cd90f682cfaf", + "0x000000000000000000000000000000000006fb4043b506b634f073a3cac2346e", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -1379,57 +1491,17 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000005202c34600815583df0c2d0e0b711d9da9", - "0x000000000000000000000000000000000013c8db79f7fdf811172fde1144dee9", - "0x00000000000000000000000000000052109b26b144a2cdc1af4e5e60c04be21a", - "0x00000000000000000000000000000000002393c00b1515c1404d7d61513a265f", - "0x0000000000000000000000000000007241727fbbf4010a2c843195cdbeafd157", - "0x00000000000000000000000000000000000a795ef6998b55f779b66ac9d12933", - "0x0000000000000000000000000000001aee6f0314cb405e0bb90e540c1d4b5825", - "0x0000000000000000000000000000000000224ad4b3d1292b0599b3a2d611f162", - "0x000000000000000000000000000000f91ff5901f79ce2e9d2658719987ab0623", - "0x00000000000000000000000000000000001805237be733c97c8936141b767f20", - "0x000000000000000000000000000000a463dafbf5544b77b523e6d0b2e184f1b7", - "0x00000000000000000000000000000000000dd5ca5243a5f9287374bfe50d7231", - "0x000000000000000000000000000000d9d38a9ffb02c68fde1512e5bd4c4c14a1", - "0x00000000000000000000000000000000001feb05f2a116d8eb36aa9d0d39a059", - "0x00000000000000000000000000000036722e643e3ae6ed827a7a3545cb08d7af", - "0x00000000000000000000000000000000002a3543973beaa6206a0c0a81bc4d00", - "0x000000000000000000000000000000df116db890832c4330270e033c9c5b4672", - "0x000000000000000000000000000000000023249bec10f97d4e917ac37cd51f84", - "0x0000000000000000000000000000008c2ac8784c4c7231ef13cf8a40238cde28", - "0x00000000000000000000000000000000001a796365a3f5248fe27f83bbdfc204", - "0x0000000000000000000000000000004d37afbe9da8f90b8baf6fc91e16d8d686", - "0x0000000000000000000000000000000000239d7a93793b18511f1718afa60011", - "0x0000000000000000000000000000006553c4d22e787acd03956f3b68568d5af6", - "0x000000000000000000000000000000000019f0fa65aacb4f914e73a29b12ff95", - "0x00000000000000000000000000000021f7c2075b834340682cd55e057cd40797", - "0x000000000000000000000000000000000020cf3ed909b8b916f364f3e092d695", - "0x000000000000000000000000000000560c871bf2b8a17f94e0ee25d928b95ba5", - "0x000000000000000000000000000000000024ae77e31b4f17dd55e0eec865690d", - "0x00000000000000000000000000000084690b7ac3d1dddfcaa97b06bda3931daf", - "0x00000000000000000000000000000000002e5eea7caf51d4bf55b60a155b924a", - "0x0000000000000000000000000000004739db956c4c8cadd30b1ddf710b76bef3", - "0x00000000000000000000000000000000000c167a87058b33567470ed345dd62c", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x000000000000000000000000000000f358d0d158178b8c1c5d1ab306fc824c6e", - "0x00000000000000000000000000000000001bfd8927e824b9139109755ac78ae8", - "0x0000000000000000000000000000009f633351b5460cd99ae56aa83c0a509e80", - "0x000000000000000000000000000000000007a02b5dd7f155aba055ff7b97cefc", - "0x000000000000000000000000000000b4411838e9bff24af3fd0a5d83f0c11530", - "0x0000000000000000000000000000000000151208bcc3e48a87e85b4589c38db6", - "0x000000000000000000000000000000c97cd77b3a0e92086255723ecaf28d7e38", - "0x00000000000000000000000000000000000200b49f18b0213dd44e92f80d6c8f", - "0x000000000000000000000000000000ca55dc2b5233494a2fec946463b3580977", - "0x000000000000000000000000000000000002f0544254905ba4070d96e3cad8f5", - "0x000000000000000000000000000000a64246255e19fd5bfda22d42dfa6f33a06", - "0x00000000000000000000000000000000000f00cca836c24c894ef5b80652121b", - "0x00000000000000000000000000000064af99efc74cc9f94032445418dfe0ca63", - "0x00000000000000000000000000000000002ccbc5204c523afd51ef21b0d7297a", - "0x000000000000000000000000000000d3014926288a126140b79c57f8a1e3adf4", - "0x00000000000000000000000000000000002ea5f5bf7c4bbd05edf988f1b9319d" + "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", + "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", + "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", + "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", + "0x000000000000000000000000000000b7706573ae35aae380eb81dd17c191254b", + "0x0000000000000000000000000000000000069a27efdadc54de4abe0a5375c701", + "0x00000000000000000000000000000046a5d1aeed6e4379e7d5bf09b713bacb61", + "0x000000000000000000000000000000000013dd4801aa5f436a77fb7c25f3bff1" ] - hash = "0x01343c2fd6c1ffb7f74e657666d03b4842aa647357eeafa82c9a740c7ab7c0f5" + hash = "0x0a40d8fb2fc541cc0b9b3febc6c4631e553ca477585110a465fa0629f5a8bb84" diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-empty-tx/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-empty-tx/Prover.toml index 725258425a8f..b2bc95dd4c40 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-empty-tx/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-empty-tx/Prover.toml @@ -1,6 +1,16 @@ [inputs] timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186" -new_l1_to_l2_message_subtree_root_sibling_path = [ +l1_to_l2_message_frontier_hint = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f", "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad", "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da", @@ -61,558 +71,6 @@ new_archive_sibling_path = [ "0x2aad701e57c7069cb4e148d971c0eae9ac7429d7d833c51d87875ead0c5aca3c" ] - [inputs.parity_root] - proof = [ - "0x0000000000000000000000000000000000000000000000000000000000000001", - "0x0000000000000000000000000000000000000000000000000000000000000002", - "0x0000000000000000000000000000000000000000000000000000000000000003", - "0x0000000000000000000000000000000000000000000000000000000000000004", - "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x0000000000000000000000000000000000000000000000000000000000000006", - "0x0000000000000000000000000000000000000000000000000000000000000007", - "0x0000000000000000000000000000000000000000000000000000000000000008", - "0x0000000000000000000000000000000000000000000000000000000000000009", - "0x000000000000000000000000000000000000000000000000000000000000000a", - "0x000000000000000000000000000000000000000000000000000000000000000b", - "0x000000000000000000000000000000000000000000000000000000000000000c", - "0x000000000000000000000000000000000000000000000000000000000000000d", - "0x000000000000000000000000000000000000000000000000000000000000000e", - "0x000000000000000000000000000000000000000000000000000000000000000f", - "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x0000000000000000000000000000000000000000000000000000000000000011", - "0x0000000000000000000000000000000000000000000000000000000000000012", - "0x0000000000000000000000000000000000000000000000000000000000000013", - "0x0000000000000000000000000000000000000000000000000000000000000014", - "0x0000000000000000000000000000000000000000000000000000000000000015", - "0x0000000000000000000000000000000000000000000000000000000000000016", - "0x0000000000000000000000000000000000000000000000000000000000000017", - "0x0000000000000000000000000000000000000000000000000000000000000018", - "0x0000000000000000000000000000000000000000000000000000000000000019", - "0x000000000000000000000000000000000000000000000000000000000000001a", - "0x000000000000000000000000000000000000000000000000000000000000001b", - "0x000000000000000000000000000000000000000000000000000000000000001c", - "0x000000000000000000000000000000000000000000000000000000000000001d", - "0x000000000000000000000000000000000000000000000000000000000000001e", - "0x000000000000000000000000000000000000000000000000000000000000001f", - "0x0000000000000000000000000000000000000000000000000000000000000020", - "0x0000000000000000000000000000000000000000000000000000000000000021", - "0x0000000000000000000000000000000000000000000000000000000000000022", - "0x0000000000000000000000000000000000000000000000000000000000000023", - "0x0000000000000000000000000000000000000000000000000000000000000024", - "0x0000000000000000000000000000000000000000000000000000000000000025", - "0x0000000000000000000000000000000000000000000000000000000000000026", - "0x0000000000000000000000000000000000000000000000000000000000000027", - "0x0000000000000000000000000000000000000000000000000000000000000028", - "0x0000000000000000000000000000000000000000000000000000000000000029", - "0x000000000000000000000000000000000000000000000000000000000000002a", - "0x000000000000000000000000000000000000000000000000000000000000002b", - "0x000000000000000000000000000000000000000000000000000000000000002c", - "0x000000000000000000000000000000000000000000000000000000000000002d", - "0x000000000000000000000000000000000000000000000000000000000000002e", - "0x000000000000000000000000000000000000000000000000000000000000002f", - "0x0000000000000000000000000000000000000000000000000000000000000030", - "0x0000000000000000000000000000000000000000000000000000000000000031", - "0x0000000000000000000000000000000000000000000000000000000000000032", - "0x0000000000000000000000000000000000000000000000000000000000000033", - "0x0000000000000000000000000000000000000000000000000000000000000034", - "0x0000000000000000000000000000000000000000000000000000000000000035", - "0x0000000000000000000000000000000000000000000000000000000000000036", - "0x0000000000000000000000000000000000000000000000000000000000000037", - "0x0000000000000000000000000000000000000000000000000000000000000038", - "0x0000000000000000000000000000000000000000000000000000000000000039", - "0x000000000000000000000000000000000000000000000000000000000000003a", - "0x000000000000000000000000000000000000000000000000000000000000003b", - "0x000000000000000000000000000000000000000000000000000000000000003c", - "0x000000000000000000000000000000000000000000000000000000000000003d", - "0x000000000000000000000000000000000000000000000000000000000000003e", - "0x000000000000000000000000000000000000000000000000000000000000003f", - "0x0000000000000000000000000000000000000000000000000000000000000040", - "0x0000000000000000000000000000000000000000000000000000000000000041", - "0x0000000000000000000000000000000000000000000000000000000000000042", - "0x0000000000000000000000000000000000000000000000000000000000000043", - "0x0000000000000000000000000000000000000000000000000000000000000044", - "0x0000000000000000000000000000000000000000000000000000000000000045", - "0x0000000000000000000000000000000000000000000000000000000000000046", - "0x0000000000000000000000000000000000000000000000000000000000000047", - "0x0000000000000000000000000000000000000000000000000000000000000048", - "0x0000000000000000000000000000000000000000000000000000000000000049", - "0x000000000000000000000000000000000000000000000000000000000000004a", - "0x000000000000000000000000000000000000000000000000000000000000004b", - "0x000000000000000000000000000000000000000000000000000000000000004c", - "0x000000000000000000000000000000000000000000000000000000000000004d", - "0x000000000000000000000000000000000000000000000000000000000000004e", - "0x000000000000000000000000000000000000000000000000000000000000004f", - "0x0000000000000000000000000000000000000000000000000000000000000050", - "0x0000000000000000000000000000000000000000000000000000000000000051", - "0x0000000000000000000000000000000000000000000000000000000000000052", - "0x0000000000000000000000000000000000000000000000000000000000000053", - "0x0000000000000000000000000000000000000000000000000000000000000054", - "0x0000000000000000000000000000000000000000000000000000000000000055", - "0x0000000000000000000000000000000000000000000000000000000000000056", - "0x0000000000000000000000000000000000000000000000000000000000000057", - "0x0000000000000000000000000000000000000000000000000000000000000058", - "0x0000000000000000000000000000000000000000000000000000000000000059", - "0x000000000000000000000000000000000000000000000000000000000000005a", - "0x000000000000000000000000000000000000000000000000000000000000005b", - "0x000000000000000000000000000000000000000000000000000000000000005c", - "0x000000000000000000000000000000000000000000000000000000000000005d", - "0x000000000000000000000000000000000000000000000000000000000000005e", - "0x000000000000000000000000000000000000000000000000000000000000005f", - "0x0000000000000000000000000000000000000000000000000000000000000060", - "0x0000000000000000000000000000000000000000000000000000000000000061", - "0x0000000000000000000000000000000000000000000000000000000000000062", - "0x0000000000000000000000000000000000000000000000000000000000000063", - "0x0000000000000000000000000000000000000000000000000000000000000064", - "0x0000000000000000000000000000000000000000000000000000000000000065", - "0x0000000000000000000000000000000000000000000000000000000000000066", - "0x0000000000000000000000000000000000000000000000000000000000000067", - "0x0000000000000000000000000000000000000000000000000000000000000068", - "0x0000000000000000000000000000000000000000000000000000000000000069", - "0x000000000000000000000000000000000000000000000000000000000000006a", - "0x000000000000000000000000000000000000000000000000000000000000006b", - "0x000000000000000000000000000000000000000000000000000000000000006c", - "0x000000000000000000000000000000000000000000000000000000000000006d", - "0x000000000000000000000000000000000000000000000000000000000000006e", - "0x000000000000000000000000000000000000000000000000000000000000006f", - "0x0000000000000000000000000000000000000000000000000000000000000070", - "0x0000000000000000000000000000000000000000000000000000000000000071", - "0x0000000000000000000000000000000000000000000000000000000000000072", - "0x0000000000000000000000000000000000000000000000000000000000000073", - "0x0000000000000000000000000000000000000000000000000000000000000074", - "0x0000000000000000000000000000000000000000000000000000000000000075", - "0x0000000000000000000000000000000000000000000000000000000000000076", - "0x0000000000000000000000000000000000000000000000000000000000000077", - "0x0000000000000000000000000000000000000000000000000000000000000078", - "0x0000000000000000000000000000000000000000000000000000000000000079", - "0x000000000000000000000000000000000000000000000000000000000000007a", - "0x000000000000000000000000000000000000000000000000000000000000007b", - "0x000000000000000000000000000000000000000000000000000000000000007c", - "0x000000000000000000000000000000000000000000000000000000000000007d", - "0x000000000000000000000000000000000000000000000000000000000000007e", - "0x000000000000000000000000000000000000000000000000000000000000007f", - "0x0000000000000000000000000000000000000000000000000000000000000080", - "0x0000000000000000000000000000000000000000000000000000000000000081", - "0x0000000000000000000000000000000000000000000000000000000000000082", - "0x0000000000000000000000000000000000000000000000000000000000000083", - "0x0000000000000000000000000000000000000000000000000000000000000084", - "0x0000000000000000000000000000000000000000000000000000000000000085", - "0x0000000000000000000000000000000000000000000000000000000000000086", - "0x0000000000000000000000000000000000000000000000000000000000000087", - "0x0000000000000000000000000000000000000000000000000000000000000088", - "0x0000000000000000000000000000000000000000000000000000000000000089", - "0x000000000000000000000000000000000000000000000000000000000000008a", - "0x000000000000000000000000000000000000000000000000000000000000008b", - "0x000000000000000000000000000000000000000000000000000000000000008c", - "0x000000000000000000000000000000000000000000000000000000000000008d", - "0x000000000000000000000000000000000000000000000000000000000000008e", - "0x000000000000000000000000000000000000000000000000000000000000008f", - "0x0000000000000000000000000000000000000000000000000000000000000090", - "0x0000000000000000000000000000000000000000000000000000000000000091", - "0x0000000000000000000000000000000000000000000000000000000000000092", - "0x0000000000000000000000000000000000000000000000000000000000000093", - "0x0000000000000000000000000000000000000000000000000000000000000094", - "0x0000000000000000000000000000000000000000000000000000000000000095", - "0x0000000000000000000000000000000000000000000000000000000000000096", - "0x0000000000000000000000000000000000000000000000000000000000000097", - "0x0000000000000000000000000000000000000000000000000000000000000098", - "0x0000000000000000000000000000000000000000000000000000000000000099", - "0x000000000000000000000000000000000000000000000000000000000000009a", - "0x000000000000000000000000000000000000000000000000000000000000009b", - "0x000000000000000000000000000000000000000000000000000000000000009c", - "0x000000000000000000000000000000000000000000000000000000000000009d", - "0x000000000000000000000000000000000000000000000000000000000000009e", - "0x000000000000000000000000000000000000000000000000000000000000009f", - "0x00000000000000000000000000000000000000000000000000000000000000a0", - "0x00000000000000000000000000000000000000000000000000000000000000a1", - "0x00000000000000000000000000000000000000000000000000000000000000a2", - "0x00000000000000000000000000000000000000000000000000000000000000a3", - "0x00000000000000000000000000000000000000000000000000000000000000a4", - "0x00000000000000000000000000000000000000000000000000000000000000a5", - "0x00000000000000000000000000000000000000000000000000000000000000a6", - "0x00000000000000000000000000000000000000000000000000000000000000a7", - "0x00000000000000000000000000000000000000000000000000000000000000a8", - "0x00000000000000000000000000000000000000000000000000000000000000a9", - "0x00000000000000000000000000000000000000000000000000000000000000aa", - "0x00000000000000000000000000000000000000000000000000000000000000ab", - "0x00000000000000000000000000000000000000000000000000000000000000ac", - "0x00000000000000000000000000000000000000000000000000000000000000ad", - "0x00000000000000000000000000000000000000000000000000000000000000ae", - "0x00000000000000000000000000000000000000000000000000000000000000af", - "0x00000000000000000000000000000000000000000000000000000000000000b0", - "0x00000000000000000000000000000000000000000000000000000000000000b1", - "0x00000000000000000000000000000000000000000000000000000000000000b2", - "0x00000000000000000000000000000000000000000000000000000000000000b3", - "0x00000000000000000000000000000000000000000000000000000000000000b4", - "0x00000000000000000000000000000000000000000000000000000000000000b5", - "0x00000000000000000000000000000000000000000000000000000000000000b6", - "0x00000000000000000000000000000000000000000000000000000000000000b7", - "0x00000000000000000000000000000000000000000000000000000000000000b8", - "0x00000000000000000000000000000000000000000000000000000000000000b9", - "0x00000000000000000000000000000000000000000000000000000000000000ba", - "0x00000000000000000000000000000000000000000000000000000000000000bb", - "0x00000000000000000000000000000000000000000000000000000000000000bc", - "0x00000000000000000000000000000000000000000000000000000000000000bd", - "0x00000000000000000000000000000000000000000000000000000000000000be", - "0x00000000000000000000000000000000000000000000000000000000000000bf", - "0x00000000000000000000000000000000000000000000000000000000000000c0", - "0x00000000000000000000000000000000000000000000000000000000000000c1", - "0x00000000000000000000000000000000000000000000000000000000000000c2", - "0x00000000000000000000000000000000000000000000000000000000000000c3", - "0x00000000000000000000000000000000000000000000000000000000000000c4", - "0x00000000000000000000000000000000000000000000000000000000000000c5", - "0x00000000000000000000000000000000000000000000000000000000000000c6", - "0x00000000000000000000000000000000000000000000000000000000000000c7", - "0x00000000000000000000000000000000000000000000000000000000000000c8", - "0x00000000000000000000000000000000000000000000000000000000000000c9", - "0x00000000000000000000000000000000000000000000000000000000000000ca", - "0x00000000000000000000000000000000000000000000000000000000000000cb", - "0x00000000000000000000000000000000000000000000000000000000000000cc", - "0x00000000000000000000000000000000000000000000000000000000000000cd", - "0x00000000000000000000000000000000000000000000000000000000000000ce", - "0x00000000000000000000000000000000000000000000000000000000000000cf", - "0x00000000000000000000000000000000000000000000000000000000000000d0", - "0x00000000000000000000000000000000000000000000000000000000000000d1", - "0x00000000000000000000000000000000000000000000000000000000000000d2", - "0x00000000000000000000000000000000000000000000000000000000000000d3", - "0x00000000000000000000000000000000000000000000000000000000000000d4", - "0x00000000000000000000000000000000000000000000000000000000000000d5", - "0x00000000000000000000000000000000000000000000000000000000000000d6", - "0x00000000000000000000000000000000000000000000000000000000000000d7", - "0x00000000000000000000000000000000000000000000000000000000000000d8", - "0x00000000000000000000000000000000000000000000000000000000000000d9", - "0x00000000000000000000000000000000000000000000000000000000000000da", - "0x00000000000000000000000000000000000000000000000000000000000000db", - "0x00000000000000000000000000000000000000000000000000000000000000dc", - "0x00000000000000000000000000000000000000000000000000000000000000dd", - "0x00000000000000000000000000000000000000000000000000000000000000de", - "0x00000000000000000000000000000000000000000000000000000000000000df", - "0x00000000000000000000000000000000000000000000000000000000000000e0", - "0x00000000000000000000000000000000000000000000000000000000000000e1", - "0x00000000000000000000000000000000000000000000000000000000000000e2", - "0x00000000000000000000000000000000000000000000000000000000000000e3", - "0x00000000000000000000000000000000000000000000000000000000000000e4", - "0x00000000000000000000000000000000000000000000000000000000000000e5", - "0x00000000000000000000000000000000000000000000000000000000000000e6", - "0x00000000000000000000000000000000000000000000000000000000000000e7", - "0x00000000000000000000000000000000000000000000000000000000000000e8", - "0x00000000000000000000000000000000000000000000000000000000000000e9", - "0x00000000000000000000000000000000000000000000000000000000000000ea", - "0x00000000000000000000000000000000000000000000000000000000000000eb", - "0x00000000000000000000000000000000000000000000000000000000000000ec", - "0x00000000000000000000000000000000000000000000000000000000000000ed", - "0x00000000000000000000000000000000000000000000000000000000000000ee", - "0x00000000000000000000000000000000000000000000000000000000000000ef", - "0x00000000000000000000000000000000000000000000000000000000000000f0", - "0x00000000000000000000000000000000000000000000000000000000000000f1", - "0x00000000000000000000000000000000000000000000000000000000000000f2", - "0x00000000000000000000000000000000000000000000000000000000000000f3", - "0x00000000000000000000000000000000000000000000000000000000000000f4", - "0x00000000000000000000000000000000000000000000000000000000000000f5", - "0x00000000000000000000000000000000000000000000000000000000000000f6", - "0x00000000000000000000000000000000000000000000000000000000000000f7", - "0x00000000000000000000000000000000000000000000000000000000000000f8", - "0x00000000000000000000000000000000000000000000000000000000000000f9", - "0x00000000000000000000000000000000000000000000000000000000000000fa", - "0x00000000000000000000000000000000000000000000000000000000000000fb", - "0x00000000000000000000000000000000000000000000000000000000000000fc", - "0x00000000000000000000000000000000000000000000000000000000000000fd", - "0x00000000000000000000000000000000000000000000000000000000000000fe", - "0x00000000000000000000000000000000000000000000000000000000000000ff", - "0x0000000000000000000000000000000000000000000000000000000000000100", - "0x0000000000000000000000000000000000000000000000000000000000000101", - "0x0000000000000000000000000000000000000000000000000000000000000102", - "0x0000000000000000000000000000000000000000000000000000000000000103", - "0x0000000000000000000000000000000000000000000000000000000000000104", - "0x0000000000000000000000000000000000000000000000000000000000000105", - "0x0000000000000000000000000000000000000000000000000000000000000106", - "0x0000000000000000000000000000000000000000000000000000000000000107", - "0x0000000000000000000000000000000000000000000000000000000000000108", - "0x0000000000000000000000000000000000000000000000000000000000000109", - "0x000000000000000000000000000000000000000000000000000000000000010a", - "0x000000000000000000000000000000000000000000000000000000000000010b", - "0x000000000000000000000000000000000000000000000000000000000000010c", - "0x000000000000000000000000000000000000000000000000000000000000010d", - "0x000000000000000000000000000000000000000000000000000000000000010e", - "0x000000000000000000000000000000000000000000000000000000000000010f", - "0x0000000000000000000000000000000000000000000000000000000000000110", - "0x0000000000000000000000000000000000000000000000000000000000000111", - "0x0000000000000000000000000000000000000000000000000000000000000112", - "0x0000000000000000000000000000000000000000000000000000000000000113", - "0x0000000000000000000000000000000000000000000000000000000000000114", - "0x0000000000000000000000000000000000000000000000000000000000000115", - "0x0000000000000000000000000000000000000000000000000000000000000116", - "0x0000000000000000000000000000000000000000000000000000000000000117", - "0x0000000000000000000000000000000000000000000000000000000000000118", - "0x0000000000000000000000000000000000000000000000000000000000000119", - "0x000000000000000000000000000000000000000000000000000000000000011a", - "0x000000000000000000000000000000000000000000000000000000000000011b", - "0x000000000000000000000000000000000000000000000000000000000000011c", - "0x000000000000000000000000000000000000000000000000000000000000011d", - "0x000000000000000000000000000000000000000000000000000000000000011e", - "0x000000000000000000000000000000000000000000000000000000000000011f", - "0x0000000000000000000000000000000000000000000000000000000000000120", - "0x0000000000000000000000000000000000000000000000000000000000000121", - "0x0000000000000000000000000000000000000000000000000000000000000122", - "0x0000000000000000000000000000000000000000000000000000000000000123", - "0x0000000000000000000000000000000000000000000000000000000000000124", - "0x0000000000000000000000000000000000000000000000000000000000000125", - "0x0000000000000000000000000000000000000000000000000000000000000126", - "0x0000000000000000000000000000000000000000000000000000000000000127", - "0x0000000000000000000000000000000000000000000000000000000000000128", - "0x0000000000000000000000000000000000000000000000000000000000000129", - "0x000000000000000000000000000000000000000000000000000000000000012a", - "0x000000000000000000000000000000000000000000000000000000000000012b", - "0x000000000000000000000000000000000000000000000000000000000000012c", - "0x000000000000000000000000000000000000000000000000000000000000012d", - "0x000000000000000000000000000000000000000000000000000000000000012e", - "0x000000000000000000000000000000000000000000000000000000000000012f", - "0x0000000000000000000000000000000000000000000000000000000000000130", - "0x0000000000000000000000000000000000000000000000000000000000000131", - "0x0000000000000000000000000000000000000000000000000000000000000132", - "0x0000000000000000000000000000000000000000000000000000000000000133", - "0x0000000000000000000000000000000000000000000000000000000000000134", - "0x0000000000000000000000000000000000000000000000000000000000000135", - "0x0000000000000000000000000000000000000000000000000000000000000136", - "0x0000000000000000000000000000000000000000000000000000000000000137", - "0x0000000000000000000000000000000000000000000000000000000000000138", - "0x0000000000000000000000000000000000000000000000000000000000000139", - "0x000000000000000000000000000000000000000000000000000000000000013a", - "0x000000000000000000000000000000000000000000000000000000000000013b", - "0x000000000000000000000000000000000000000000000000000000000000013c", - "0x000000000000000000000000000000000000000000000000000000000000013d", - "0x000000000000000000000000000000000000000000000000000000000000013e", - "0x000000000000000000000000000000000000000000000000000000000000013f", - "0x0000000000000000000000000000000000000000000000000000000000000140", - "0x0000000000000000000000000000000000000000000000000000000000000141", - "0x0000000000000000000000000000000000000000000000000000000000000142", - "0x0000000000000000000000000000000000000000000000000000000000000143", - "0x0000000000000000000000000000000000000000000000000000000000000144", - "0x0000000000000000000000000000000000000000000000000000000000000145", - "0x0000000000000000000000000000000000000000000000000000000000000146", - "0x0000000000000000000000000000000000000000000000000000000000000147", - "0x0000000000000000000000000000000000000000000000000000000000000148", - "0x0000000000000000000000000000000000000000000000000000000000000149", - "0x000000000000000000000000000000000000000000000000000000000000014a", - "0x000000000000000000000000000000000000000000000000000000000000014b", - "0x000000000000000000000000000000000000000000000000000000000000014c", - "0x000000000000000000000000000000000000000000000000000000000000014d", - "0x000000000000000000000000000000000000000000000000000000000000014e", - "0x000000000000000000000000000000000000000000000000000000000000014f", - "0x0000000000000000000000000000000000000000000000000000000000000150", - "0x0000000000000000000000000000000000000000000000000000000000000151", - "0x0000000000000000000000000000000000000000000000000000000000000152", - "0x0000000000000000000000000000000000000000000000000000000000000153", - "0x0000000000000000000000000000000000000000000000000000000000000154", - "0x0000000000000000000000000000000000000000000000000000000000000155", - "0x0000000000000000000000000000000000000000000000000000000000000156", - "0x0000000000000000000000000000000000000000000000000000000000000157", - "0x0000000000000000000000000000000000000000000000000000000000000158", - "0x0000000000000000000000000000000000000000000000000000000000000159", - "0x000000000000000000000000000000000000000000000000000000000000015a", - "0x000000000000000000000000000000000000000000000000000000000000015b", - "0x000000000000000000000000000000000000000000000000000000000000015c", - "0x000000000000000000000000000000000000000000000000000000000000015d", - "0x000000000000000000000000000000000000000000000000000000000000015e", - "0x000000000000000000000000000000000000000000000000000000000000015f", - "0x0000000000000000000000000000000000000000000000000000000000000160", - "0x0000000000000000000000000000000000000000000000000000000000000161", - "0x0000000000000000000000000000000000000000000000000000000000000162", - "0x0000000000000000000000000000000000000000000000000000000000000163", - "0x0000000000000000000000000000000000000000000000000000000000000164", - "0x0000000000000000000000000000000000000000000000000000000000000165", - "0x0000000000000000000000000000000000000000000000000000000000000166", - "0x0000000000000000000000000000000000000000000000000000000000000167", - "0x0000000000000000000000000000000000000000000000000000000000000168", - "0x0000000000000000000000000000000000000000000000000000000000000169", - "0x000000000000000000000000000000000000000000000000000000000000016a", - "0x000000000000000000000000000000000000000000000000000000000000016b", - "0x000000000000000000000000000000000000000000000000000000000000016c", - "0x000000000000000000000000000000000000000000000000000000000000016d", - "0x000000000000000000000000000000000000000000000000000000000000016e", - "0x000000000000000000000000000000000000000000000000000000000000016f", - "0x0000000000000000000000000000000000000000000000000000000000000170", - "0x0000000000000000000000000000000000000000000000000000000000000171", - "0x0000000000000000000000000000000000000000000000000000000000000172", - "0x0000000000000000000000000000000000000000000000000000000000000173", - "0x0000000000000000000000000000000000000000000000000000000000000174", - "0x0000000000000000000000000000000000000000000000000000000000000175", - "0x0000000000000000000000000000000000000000000000000000000000000176", - "0x0000000000000000000000000000000000000000000000000000000000000177", - "0x0000000000000000000000000000000000000000000000000000000000000178", - "0x0000000000000000000000000000000000000000000000000000000000000179", - "0x000000000000000000000000000000000000000000000000000000000000017a", - "0x000000000000000000000000000000000000000000000000000000000000017b", - "0x000000000000000000000000000000000000000000000000000000000000017c", - "0x000000000000000000000000000000000000000000000000000000000000017d", - "0x000000000000000000000000000000000000000000000000000000000000017e", - "0x000000000000000000000000000000000000000000000000000000000000017f", - "0x0000000000000000000000000000000000000000000000000000000000000180", - "0x0000000000000000000000000000000000000000000000000000000000000181", - "0x0000000000000000000000000000000000000000000000000000000000000182", - "0x0000000000000000000000000000000000000000000000000000000000000183", - "0x0000000000000000000000000000000000000000000000000000000000000184", - "0x0000000000000000000000000000000000000000000000000000000000000185", - "0x0000000000000000000000000000000000000000000000000000000000000186", - "0x0000000000000000000000000000000000000000000000000000000000000187", - "0x0000000000000000000000000000000000000000000000000000000000000188", - "0x0000000000000000000000000000000000000000000000000000000000000189", - "0x000000000000000000000000000000000000000000000000000000000000018a", - "0x000000000000000000000000000000000000000000000000000000000000018b", - "0x000000000000000000000000000000000000000000000000000000000000018c", - "0x000000000000000000000000000000000000000000000000000000000000018d", - "0x000000000000000000000000000000000000000000000000000000000000018e", - "0x000000000000000000000000000000000000000000000000000000000000018f", - "0x0000000000000000000000000000000000000000000000000000000000000190", - "0x0000000000000000000000000000000000000000000000000000000000000191", - "0x0000000000000000000000000000000000000000000000000000000000000192", - "0x0000000000000000000000000000000000000000000000000000000000000193", - "0x0000000000000000000000000000000000000000000000000000000000000194", - "0x0000000000000000000000000000000000000000000000000000000000000195", - "0x0000000000000000000000000000000000000000000000000000000000000196", - "0x0000000000000000000000000000000000000000000000000000000000000197", - "0x0000000000000000000000000000000000000000000000000000000000000198", - "0x0000000000000000000000000000000000000000000000000000000000000199", - "0x000000000000000000000000000000000000000000000000000000000000019a" -] - - [inputs.parity_root.public_inputs] - sha_root = "0x00b0e02949c7c042e780651385688dcec114af3dbb3892bab1a9cd8e2bbafdc5" - converted_root = "0x2f7247450c6d856804ef9fade0d5af92e4b87b1576f07ec88359012bf4c21abf" - vk_tree_root = "0x11065543c9a42eac842466277ee9149b27403e398e94c6bba4f525931a2ac6bc" - prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" - - [inputs.parity_root.vk_data] - leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000016" - sibling_path = [ - "0x0f32425668cad3847a3ac0f871f98e235c4df15eb323b35d1bcee45576cff894", - "0x265fc4a3319a624ef133d498afc59fa5976e915d1e6770f924dd2913c001ae1d", - "0x1c47417eb2dc267d6e655a2150a05647d9280b96be65539aa158c6c46ca26969", - "0x2741ff7d37d2b0c0b75babfe4e7c3c94262ecd1a7aa5cde310a785c22821ba43", - "0x0f562a30dbca79c1e0123045d842e92b28e6d47450898bf672592537e3b86163", - "0x1c7b07f7b3f8344fece2e6a10bc9480dc4b90f89d2a51f344bee80ca5a4bda6e", - "0x12ed8e93726f8b5b79d1291566a72c1775861d60bba2daa19edb3f28d0ae7a3e" -] - - [inputs.parity_root.vk_data.vk] - key = [ - "0x0000000000000000000000000000000000000000000000000000000000000016", - "0x000000000000000000000000000000000000000000000000000000000000000c", - "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x000000000000000000000000000000ffe755d8b3c57a1ab614512a4bedf19549", - "0x00000000000000000000000000000000000534da51986a838ae9c1792f2626e5", - "0x0000000000000000000000000000006ec5a4c07aa9de1b4d1622c25d851173b7", - "0x00000000000000000000000000000000001f7cc23b1a4486149ad1e8f97bc8fe", - "0x000000000000000000000000000000c65b28eb1be8ff3fba908d84f31181e8d1", - "0x000000000000000000000000000000000025b7e8b68a99cbf3a62e5a122483a3", - "0x000000000000000000000000000000bc231c09845555a404d388207beb4e797f", - "0x000000000000000000000000000000000016e17e8b5bfd5f0f0f274e3353ca27", - "0x0000000000000000000000000000001f0e86a5ee3b8134d872edb4a60d5ff6f1", - "0x00000000000000000000000000000000002a0177d3ec4ad4c379c0e2cf7189f7", - "0x00000000000000000000000000000007f4c0a1986540d335d55141ca6b084401", - "0x00000000000000000000000000000000000afc61b084b6c1333e18f61907bce6", - "0x000000000000000000000000000000945e9e96b7f2fc82278b5b6872e9971cfd", - "0x00000000000000000000000000000000002fcd10bc1f098fd35129cf5028c20a", - "0x000000000000000000000000000000d660c3c7aa2141f169e733f8624cdfaf30", - "0x00000000000000000000000000000000002d136c80a84a6cc3d0edc85f1ddb5e", - "0x00000000000000000000000000000019b846fcf3cbd0fe88fb0ea0a36dcc317c", - "0x00000000000000000000000000000000001f6e082c765eb5f7751204bc42a5d4", - "0x000000000000000000000000000000c1892b383cec3510bf322c430821c6f092", - "0x00000000000000000000000000000000000b1872d98dc6e92c02a654071f8189", - "0x0000000000000000000000000000005a50e192dd251cb43ea57484becf366e85", - "0x000000000000000000000000000000000003ba6440f3f173c213b050800e042f", - "0x0000000000000000000000000000007944d08a075210d9dd10d1662ff8e5878e", - "0x00000000000000000000000000000000000a02396b3dbafce1dc3bcd2851bced", - "0x000000000000000000000000000000ce97a1200ac29836f9aa4b2b6e7a0f85a8", - "0x0000000000000000000000000000000000114252197e7829a46578e5f6f14e35", - "0x00000000000000000000000000000089644b4427a04f25fd862da89ef02b47c4", - "0x00000000000000000000000000000000001b70d9301a5c36773bcded3edd6c80", - "0x0000000000000000000000000000007ed1a5255c653cda257387c8755336e3ef", - "0x0000000000000000000000000000000000098bbdc9e2200ccd02cfc0889201a3", - "0x000000000000000000000000000000700b1f800cc62fc982ba222a3c836e28ab", - "0x00000000000000000000000000000000000440c58c9932c8b4a645dd7bf1f8f6", - "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", - "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", - "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", - "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x000000000000000000000000000000e74a52afca5802c96d87095252c73242ed", - "0x00000000000000000000000000000000001921ed8f6aa19d3b01e136443e9c43", - "0x000000000000000000000000000000e8e94042f88a31b913e55169c6fc9fd899", - "0x00000000000000000000000000000000001b38acf2cbe1b8745e483f83e05f4b", - "0x0000000000000000000000000000006eed465622852dce8a0702c5327cff0583", - "0x000000000000000000000000000000000022b0941f412859d1cc37a757ca4375", - "0x0000000000000000000000000000008bef872c634b8c03bfe7ff37c00a727192", - "0x000000000000000000000000000000000004906c8767a040a562b166a360c43b", - "0x0000000000000000000000000000002196aef3cb99415b3ac5297aac8f112fc6", - "0x0000000000000000000000000000000000202bc7de55cc5837eb14b1c9170f8b", - "0x000000000000000000000000000000bdf27b518418573439ed9eae4c5e5fb565", - "0x000000000000000000000000000000000017b3d9bbe6a673b931642f99c5da31", - "0x000000000000000000000000000000f02ba591cd0b41bb042d8e128595192f02", - "0x00000000000000000000000000000000000e91c21c980b16cf781f41a63337b6", - "0x000000000000000000000000000000df236435bb93d1ba03853ec32ce9bac516", - "0x00000000000000000000000000000000000c79c6f2ebdbb8e9a9ced4fe147b70", - "0x0000000000000000000000000000003fffb3aa510e7f700cf1014e5872d9c836", - "0x00000000000000000000000000000000002a8a152385a9322608448c3b903a25", - "0x000000000000000000000000000000e0e29574c018f3c6738e2e39d4c5add9a0", - "0x00000000000000000000000000000000000fc61b53a775b4a4abe28883bd4cae", - "0x00000000000000000000000000000015ad8f2e516ea41308c308441bd42c61e8", - "0x00000000000000000000000000000000002ae1b82b97d47244a5cbf6785de890", - "0x000000000000000000000000000000c903532912619760836806241aafc8d682", - "0x00000000000000000000000000000000000ad9c58de8e6372d34bc7aac8d1aca", - "0x000000000000000000000000000000c6e9efa1c758924d7de45017a05726fca7", - "0x00000000000000000000000000000000001da169f438cfc870048ea757c938a9", - "0x000000000000000000000000000000173aa01a946f89910fbc61ce0978f11df6", - "0x000000000000000000000000000000000010511a8cf921804a7d1a6f7d6b7e4a", - "0x000000000000000000000000000000d9292eae3d7214cf357ecbfd5450e48dc5", - "0x00000000000000000000000000000000002c4fdd575051b7aed86ed22911ebaf", - "0x000000000000000000000000000000d14cc302deb68c94d33c31626af7c943d5", - "0x00000000000000000000000000000000001fa409243e8e0d777188a76d20f835", - "0x000000000000000000000000000000f9d9dceb4a21921fa5d9edf02aa5383e77", - "0x000000000000000000000000000000000002acc34aa553acf2a60116f38df796", - "0x0000000000000000000000000000002c76aa33d3ada3dc142abb8e0a3e1191e1", - "0x0000000000000000000000000000000000147d02c32b9568f5252f6c9e1f108f", - "0x00000000000000000000000000000088a07098dc2dbe19a768a0a19614ae8f47", - "0x0000000000000000000000000000000000006f5dc4ddaf221bb7b9034c756597", - "0x000000000000000000000000000000631dc92a76396edbb65457f05dedc64864", - "0x00000000000000000000000000000000001a23a09ca622bd72a07792694d2931", - "0x00000000000000000000000000000061cb9c09b369db2c419adba705d0f8ddb3", - "0x00000000000000000000000000000000001377787d2f2084b9263c965fbf2e2c", - "0x00000000000000000000000000000099eb45fd3667ef5b823282f9deb302de03", - "0x00000000000000000000000000000000001d090be973bf574d0eb446d4ad64b2", - "0x000000000000000000000000000000c63f86d07e1aff3f0052511400edb2be2e", - "0x00000000000000000000000000000000002c65a1bf4ceba12047a3072eb5f2e0", - "0x0000000000000000000000000000002b8a4436889976e6b5cce13fb8b12327ac", - "0x00000000000000000000000000000000000585cb3553e38f6e8404d11734d67a", - "0x000000000000000000000000000000cfaf000e5b5293d4e63f49f1944eb2e05c", - "0x000000000000000000000000000000000011ddb77ef38de130795dcbc345f56e", - "0x000000000000000000000000000000c61f53c944f6d05ab07a3ee14f114138eb", - "0x000000000000000000000000000000000009ad7168055eddbe696b65fb3bddca", - "0x000000000000000000000000000000fe83caf00dfb98e145f37f5a24108f0e34", - "0x000000000000000000000000000000000013b57406261bf3d6d6f4e866b9da62", - "0x000000000000000000000000000000b9220b111331f6f8ee0ad8f6ebbaaaf462", - "0x00000000000000000000000000000000000e0f9e959f65b073ee1bedcc1efbc0", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x000000000000000000000000000000f034a50a2cc8ad7a610cacc87072f43b5e", - "0x000000000000000000000000000000000001b28e2039ba8b5fbb9a9b41d0b3d0", - "0x00000000000000000000000000000031581f609d92eb3f3edff4da364c25b2bc", - "0x000000000000000000000000000000000021cc73a6c61c10620816b6e866bb7e", - "0x000000000000000000000000000000968f7c89583557986b83af0d7c0380ffe9", - "0x0000000000000000000000000000000000071667384c3711bafccd202668b90c", - "0x000000000000000000000000000000ef6589f0004fbcb285a722163a045bb641", - "0x0000000000000000000000000000000000260b419489bfa802ea5c3746bd25a7", - "0x0000000000000000000000000000004e5ee61d5b7c158e8ee0ad7719a6118e14", - "0x00000000000000000000000000000000001eae1e642fd268200645995c408b86", - "0x000000000000000000000000000000e21942e59156a86d6dc7f28247aa5f07b8", - "0x000000000000000000000000000000000026429839f94d5b20f11ec2e82466ec", - "0x000000000000000000000000000000d881564b3e134e51c9f4a3d32e94ce84e4", - "0x00000000000000000000000000000000002ee2ded9a98c582833347ed5a0becb", - "0x000000000000000000000000000000122abebbcfad7ec560153c58baf5d58580", - "0x000000000000000000000000000000000003913b06b8b4b8b5dd5d594546c439" -] - hash = "0x2311de417e915bc1373f7386131344407c960c21a9c0dd41d74d57a53aef3eec" - [inputs.previous_archive] root = "0x0fb2945d3438d906d88a216364dbfe9760e96001343468610e01d18182d493d0" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" @@ -636,8 +94,8 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 [inputs.constants] chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" version = "0x0000000000000000000000000000000000000000000000000000000000000000" - vk_tree_root = "0x11065543c9a42eac842466277ee9149b27403e398e94c6bba4f525931a2ac6bc" - protocol_contracts_hash = "0x24b2bd6e0456d2d2e64beb505010896a57017c6dedf7516d314d551720c3e6b4" + vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f" @@ -650,3 +108,1033 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 [inputs.constants.gas_fees] fee_per_da_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.message_bundle] + messages = [ + "0x00000000000000000000000000000000000000000000000000000000000005dc", + "0x00000000000000000000000000000000000000000000000000000000000005dd", + "0x00000000000000000000000000000000000000000000000000000000000005de", + "0x00000000000000000000000000000000000000000000000000000000000005df", + "0x00000000000000000000000000000000000000000000000000000000000005e0", + "0x00000000000000000000000000000000000000000000000000000000000005e1", + "0x00000000000000000000000000000000000000000000000000000000000005e2", + "0x00000000000000000000000000000000000000000000000000000000000005e3", + "0x00000000000000000000000000000000000000000000000000000000000005e4", + "0x00000000000000000000000000000000000000000000000000000000000005e5", + "0x00000000000000000000000000000000000000000000000000000000000005e6", + "0x00000000000000000000000000000000000000000000000000000000000005e7", + "0x00000000000000000000000000000000000000000000000000000000000005e8", + "0x00000000000000000000000000000000000000000000000000000000000005e9", + "0x00000000000000000000000000000000000000000000000000000000000005ea", + "0x00000000000000000000000000000000000000000000000000000000000005eb", + "0x00000000000000000000000000000000000000000000000000000000000005ec", + "0x00000000000000000000000000000000000000000000000000000000000005ed", + "0x00000000000000000000000000000000000000000000000000000000000005ee", + "0x00000000000000000000000000000000000000000000000000000000000005ef", + "0x00000000000000000000000000000000000000000000000000000000000005f0", + "0x00000000000000000000000000000000000000000000000000000000000005f1", + "0x00000000000000000000000000000000000000000000000000000000000005f2", + "0x00000000000000000000000000000000000000000000000000000000000005f3", + "0x00000000000000000000000000000000000000000000000000000000000005f4", + "0x00000000000000000000000000000000000000000000000000000000000005f5", + "0x00000000000000000000000000000000000000000000000000000000000005f6", + "0x00000000000000000000000000000000000000000000000000000000000005f7", + "0x00000000000000000000000000000000000000000000000000000000000005f8", + "0x00000000000000000000000000000000000000000000000000000000000005f9", + "0x00000000000000000000000000000000000000000000000000000000000005fa", + "0x00000000000000000000000000000000000000000000000000000000000005fb", + "0x00000000000000000000000000000000000000000000000000000000000005fc", + "0x00000000000000000000000000000000000000000000000000000000000005fd", + "0x00000000000000000000000000000000000000000000000000000000000005fe", + "0x00000000000000000000000000000000000000000000000000000000000005ff", + "0x0000000000000000000000000000000000000000000000000000000000000600", + "0x0000000000000000000000000000000000000000000000000000000000000601", + "0x0000000000000000000000000000000000000000000000000000000000000602", + "0x0000000000000000000000000000000000000000000000000000000000000603", + "0x0000000000000000000000000000000000000000000000000000000000000604", + "0x0000000000000000000000000000000000000000000000000000000000000605", + "0x0000000000000000000000000000000000000000000000000000000000000606", + "0x0000000000000000000000000000000000000000000000000000000000000607", + "0x0000000000000000000000000000000000000000000000000000000000000608", + "0x0000000000000000000000000000000000000000000000000000000000000609", + "0x000000000000000000000000000000000000000000000000000000000000060a", + "0x000000000000000000000000000000000000000000000000000000000000060b", + "0x000000000000000000000000000000000000000000000000000000000000060c", + "0x000000000000000000000000000000000000000000000000000000000000060d", + "0x000000000000000000000000000000000000000000000000000000000000060e", + "0x000000000000000000000000000000000000000000000000000000000000060f", + "0x0000000000000000000000000000000000000000000000000000000000000610", + "0x0000000000000000000000000000000000000000000000000000000000000611", + "0x0000000000000000000000000000000000000000000000000000000000000612", + "0x0000000000000000000000000000000000000000000000000000000000000613", + "0x0000000000000000000000000000000000000000000000000000000000000614", + "0x0000000000000000000000000000000000000000000000000000000000000615", + "0x0000000000000000000000000000000000000000000000000000000000000616", + "0x0000000000000000000000000000000000000000000000000000000000000617", + "0x0000000000000000000000000000000000000000000000000000000000000618", + "0x0000000000000000000000000000000000000000000000000000000000000619", + "0x000000000000000000000000000000000000000000000000000000000000061a", + "0x000000000000000000000000000000000000000000000000000000000000061b", + "0x000000000000000000000000000000000000000000000000000000000000061c", + "0x000000000000000000000000000000000000000000000000000000000000061d", + "0x000000000000000000000000000000000000000000000000000000000000061e", + "0x000000000000000000000000000000000000000000000000000000000000061f", + "0x0000000000000000000000000000000000000000000000000000000000000620", + "0x0000000000000000000000000000000000000000000000000000000000000621", + "0x0000000000000000000000000000000000000000000000000000000000000622", + "0x0000000000000000000000000000000000000000000000000000000000000623", + "0x0000000000000000000000000000000000000000000000000000000000000624", + "0x0000000000000000000000000000000000000000000000000000000000000625", + "0x0000000000000000000000000000000000000000000000000000000000000626", + "0x0000000000000000000000000000000000000000000000000000000000000627", + "0x0000000000000000000000000000000000000000000000000000000000000628", + "0x0000000000000000000000000000000000000000000000000000000000000629", + "0x000000000000000000000000000000000000000000000000000000000000062a", + "0x000000000000000000000000000000000000000000000000000000000000062b", + "0x000000000000000000000000000000000000000000000000000000000000062c", + "0x000000000000000000000000000000000000000000000000000000000000062d", + "0x000000000000000000000000000000000000000000000000000000000000062e", + "0x000000000000000000000000000000000000000000000000000000000000062f", + "0x0000000000000000000000000000000000000000000000000000000000000630", + "0x0000000000000000000000000000000000000000000000000000000000000631", + "0x0000000000000000000000000000000000000000000000000000000000000632", + "0x0000000000000000000000000000000000000000000000000000000000000633", + "0x0000000000000000000000000000000000000000000000000000000000000634", + "0x0000000000000000000000000000000000000000000000000000000000000635", + "0x0000000000000000000000000000000000000000000000000000000000000636", + "0x0000000000000000000000000000000000000000000000000000000000000637", + "0x0000000000000000000000000000000000000000000000000000000000000638", + "0x0000000000000000000000000000000000000000000000000000000000000639", + "0x000000000000000000000000000000000000000000000000000000000000063a", + "0x000000000000000000000000000000000000000000000000000000000000063b", + "0x000000000000000000000000000000000000000000000000000000000000063c", + "0x000000000000000000000000000000000000000000000000000000000000063d", + "0x000000000000000000000000000000000000000000000000000000000000063e", + "0x000000000000000000000000000000000000000000000000000000000000063f", + "0x0000000000000000000000000000000000000000000000000000000000000640", + "0x0000000000000000000000000000000000000000000000000000000000000641", + "0x0000000000000000000000000000000000000000000000000000000000000642", + "0x0000000000000000000000000000000000000000000000000000000000000643", + "0x0000000000000000000000000000000000000000000000000000000000000644", + "0x0000000000000000000000000000000000000000000000000000000000000645", + "0x0000000000000000000000000000000000000000000000000000000000000646", + "0x0000000000000000000000000000000000000000000000000000000000000647", + "0x0000000000000000000000000000000000000000000000000000000000000648", + "0x0000000000000000000000000000000000000000000000000000000000000649", + "0x000000000000000000000000000000000000000000000000000000000000064a", + "0x000000000000000000000000000000000000000000000000000000000000064b", + "0x000000000000000000000000000000000000000000000000000000000000064c", + "0x000000000000000000000000000000000000000000000000000000000000064d", + "0x000000000000000000000000000000000000000000000000000000000000064e", + "0x000000000000000000000000000000000000000000000000000000000000064f", + "0x0000000000000000000000000000000000000000000000000000000000000650", + "0x0000000000000000000000000000000000000000000000000000000000000651", + "0x0000000000000000000000000000000000000000000000000000000000000652", + "0x0000000000000000000000000000000000000000000000000000000000000653", + "0x0000000000000000000000000000000000000000000000000000000000000654", + "0x0000000000000000000000000000000000000000000000000000000000000655", + "0x0000000000000000000000000000000000000000000000000000000000000656", + "0x0000000000000000000000000000000000000000000000000000000000000657", + "0x0000000000000000000000000000000000000000000000000000000000000658", + "0x0000000000000000000000000000000000000000000000000000000000000659", + "0x000000000000000000000000000000000000000000000000000000000000065a", + "0x000000000000000000000000000000000000000000000000000000000000065b", + "0x000000000000000000000000000000000000000000000000000000000000065c", + "0x000000000000000000000000000000000000000000000000000000000000065d", + "0x000000000000000000000000000000000000000000000000000000000000065e", + "0x000000000000000000000000000000000000000000000000000000000000065f", + "0x0000000000000000000000000000000000000000000000000000000000000660", + "0x0000000000000000000000000000000000000000000000000000000000000661", + "0x0000000000000000000000000000000000000000000000000000000000000662", + "0x0000000000000000000000000000000000000000000000000000000000000663", + "0x0000000000000000000000000000000000000000000000000000000000000664", + "0x0000000000000000000000000000000000000000000000000000000000000665", + "0x0000000000000000000000000000000000000000000000000000000000000666", + "0x0000000000000000000000000000000000000000000000000000000000000667", + "0x0000000000000000000000000000000000000000000000000000000000000668", + "0x0000000000000000000000000000000000000000000000000000000000000669", + "0x000000000000000000000000000000000000000000000000000000000000066a", + "0x000000000000000000000000000000000000000000000000000000000000066b", + "0x000000000000000000000000000000000000000000000000000000000000066c", + "0x000000000000000000000000000000000000000000000000000000000000066d", + "0x000000000000000000000000000000000000000000000000000000000000066e", + "0x000000000000000000000000000000000000000000000000000000000000066f", + "0x0000000000000000000000000000000000000000000000000000000000000670", + "0x0000000000000000000000000000000000000000000000000000000000000671", + "0x0000000000000000000000000000000000000000000000000000000000000672", + "0x0000000000000000000000000000000000000000000000000000000000000673", + "0x0000000000000000000000000000000000000000000000000000000000000674", + "0x0000000000000000000000000000000000000000000000000000000000000675", + "0x0000000000000000000000000000000000000000000000000000000000000676", + "0x0000000000000000000000000000000000000000000000000000000000000677", + "0x0000000000000000000000000000000000000000000000000000000000000678", + "0x0000000000000000000000000000000000000000000000000000000000000679", + "0x000000000000000000000000000000000000000000000000000000000000067a", + "0x000000000000000000000000000000000000000000000000000000000000067b", + "0x000000000000000000000000000000000000000000000000000000000000067c", + "0x000000000000000000000000000000000000000000000000000000000000067d", + "0x000000000000000000000000000000000000000000000000000000000000067e", + "0x000000000000000000000000000000000000000000000000000000000000067f", + "0x0000000000000000000000000000000000000000000000000000000000000680", + "0x0000000000000000000000000000000000000000000000000000000000000681", + "0x0000000000000000000000000000000000000000000000000000000000000682", + "0x0000000000000000000000000000000000000000000000000000000000000683", + "0x0000000000000000000000000000000000000000000000000000000000000684", + "0x0000000000000000000000000000000000000000000000000000000000000685", + "0x0000000000000000000000000000000000000000000000000000000000000686", + "0x0000000000000000000000000000000000000000000000000000000000000687", + "0x0000000000000000000000000000000000000000000000000000000000000688", + "0x0000000000000000000000000000000000000000000000000000000000000689", + "0x000000000000000000000000000000000000000000000000000000000000068a", + "0x000000000000000000000000000000000000000000000000000000000000068b", + "0x000000000000000000000000000000000000000000000000000000000000068c", + "0x000000000000000000000000000000000000000000000000000000000000068d", + "0x000000000000000000000000000000000000000000000000000000000000068e", + "0x000000000000000000000000000000000000000000000000000000000000068f", + "0x0000000000000000000000000000000000000000000000000000000000000690", + "0x0000000000000000000000000000000000000000000000000000000000000691", + "0x0000000000000000000000000000000000000000000000000000000000000692", + "0x0000000000000000000000000000000000000000000000000000000000000693", + "0x0000000000000000000000000000000000000000000000000000000000000694", + "0x0000000000000000000000000000000000000000000000000000000000000695", + "0x0000000000000000000000000000000000000000000000000000000000000696", + "0x0000000000000000000000000000000000000000000000000000000000000697", + "0x0000000000000000000000000000000000000000000000000000000000000698", + "0x0000000000000000000000000000000000000000000000000000000000000699", + "0x000000000000000000000000000000000000000000000000000000000000069a", + "0x000000000000000000000000000000000000000000000000000000000000069b", + "0x000000000000000000000000000000000000000000000000000000000000069c", + "0x000000000000000000000000000000000000000000000000000000000000069d", + "0x000000000000000000000000000000000000000000000000000000000000069e", + "0x000000000000000000000000000000000000000000000000000000000000069f", + "0x00000000000000000000000000000000000000000000000000000000000006a0", + "0x00000000000000000000000000000000000000000000000000000000000006a1", + "0x00000000000000000000000000000000000000000000000000000000000006a2", + "0x00000000000000000000000000000000000000000000000000000000000006a3", + "0x00000000000000000000000000000000000000000000000000000000000006a4", + "0x00000000000000000000000000000000000000000000000000000000000006a5", + "0x00000000000000000000000000000000000000000000000000000000000006a6", + "0x00000000000000000000000000000000000000000000000000000000000006a7", + "0x00000000000000000000000000000000000000000000000000000000000006a8", + "0x00000000000000000000000000000000000000000000000000000000000006a9", + "0x00000000000000000000000000000000000000000000000000000000000006aa", + "0x00000000000000000000000000000000000000000000000000000000000006ab", + "0x00000000000000000000000000000000000000000000000000000000000006ac", + "0x00000000000000000000000000000000000000000000000000000000000006ad", + "0x00000000000000000000000000000000000000000000000000000000000006ae", + "0x00000000000000000000000000000000000000000000000000000000000006af", + "0x00000000000000000000000000000000000000000000000000000000000006b0", + "0x00000000000000000000000000000000000000000000000000000000000006b1", + "0x00000000000000000000000000000000000000000000000000000000000006b2", + "0x00000000000000000000000000000000000000000000000000000000000006b3", + "0x00000000000000000000000000000000000000000000000000000000000006b4", + "0x00000000000000000000000000000000000000000000000000000000000006b5", + "0x00000000000000000000000000000000000000000000000000000000000006b6", + "0x00000000000000000000000000000000000000000000000000000000000006b7", + "0x00000000000000000000000000000000000000000000000000000000000006b8", + "0x00000000000000000000000000000000000000000000000000000000000006b9", + "0x00000000000000000000000000000000000000000000000000000000000006ba", + "0x00000000000000000000000000000000000000000000000000000000000006bb", + "0x00000000000000000000000000000000000000000000000000000000000006bc", + "0x00000000000000000000000000000000000000000000000000000000000006bd", + "0x00000000000000000000000000000000000000000000000000000000000006be", + "0x00000000000000000000000000000000000000000000000000000000000006bf", + "0x00000000000000000000000000000000000000000000000000000000000006c0", + "0x00000000000000000000000000000000000000000000000000000000000006c1", + "0x00000000000000000000000000000000000000000000000000000000000006c2", + "0x00000000000000000000000000000000000000000000000000000000000006c3", + "0x00000000000000000000000000000000000000000000000000000000000006c4", + "0x00000000000000000000000000000000000000000000000000000000000006c5", + "0x00000000000000000000000000000000000000000000000000000000000006c6", + "0x00000000000000000000000000000000000000000000000000000000000006c7", + "0x00000000000000000000000000000000000000000000000000000000000006c8", + "0x00000000000000000000000000000000000000000000000000000000000006c9", + "0x00000000000000000000000000000000000000000000000000000000000006ca", + "0x00000000000000000000000000000000000000000000000000000000000006cb", + "0x00000000000000000000000000000000000000000000000000000000000006cc", + "0x00000000000000000000000000000000000000000000000000000000000006cd", + "0x00000000000000000000000000000000000000000000000000000000000006ce", + "0x00000000000000000000000000000000000000000000000000000000000006cf", + "0x00000000000000000000000000000000000000000000000000000000000006d0", + "0x00000000000000000000000000000000000000000000000000000000000006d1", + "0x00000000000000000000000000000000000000000000000000000000000006d2", + "0x00000000000000000000000000000000000000000000000000000000000006d3", + "0x00000000000000000000000000000000000000000000000000000000000006d4", + "0x00000000000000000000000000000000000000000000000000000000000006d5", + "0x00000000000000000000000000000000000000000000000000000000000006d6", + "0x00000000000000000000000000000000000000000000000000000000000006d7", + "0x00000000000000000000000000000000000000000000000000000000000006d8", + "0x00000000000000000000000000000000000000000000000000000000000006d9", + "0x00000000000000000000000000000000000000000000000000000000000006da", + "0x00000000000000000000000000000000000000000000000000000000000006db", + "0x00000000000000000000000000000000000000000000000000000000000006dc", + "0x00000000000000000000000000000000000000000000000000000000000006dd", + "0x00000000000000000000000000000000000000000000000000000000000006de", + "0x00000000000000000000000000000000000000000000000000000000000006df", + "0x00000000000000000000000000000000000000000000000000000000000006e0", + "0x00000000000000000000000000000000000000000000000000000000000006e1", + "0x00000000000000000000000000000000000000000000000000000000000006e2", + "0x00000000000000000000000000000000000000000000000000000000000006e3", + "0x00000000000000000000000000000000000000000000000000000000000006e4", + "0x00000000000000000000000000000000000000000000000000000000000006e5", + "0x00000000000000000000000000000000000000000000000000000000000006e6", + "0x00000000000000000000000000000000000000000000000000000000000006e7", + "0x00000000000000000000000000000000000000000000000000000000000006e8", + "0x00000000000000000000000000000000000000000000000000000000000006e9", + "0x00000000000000000000000000000000000000000000000000000000000006ea", + "0x00000000000000000000000000000000000000000000000000000000000006eb", + "0x00000000000000000000000000000000000000000000000000000000000006ec", + "0x00000000000000000000000000000000000000000000000000000000000006ed", + "0x00000000000000000000000000000000000000000000000000000000000006ee", + "0x00000000000000000000000000000000000000000000000000000000000006ef", + "0x00000000000000000000000000000000000000000000000000000000000006f0", + "0x00000000000000000000000000000000000000000000000000000000000006f1", + "0x00000000000000000000000000000000000000000000000000000000000006f2", + "0x00000000000000000000000000000000000000000000000000000000000006f3", + "0x00000000000000000000000000000000000000000000000000000000000006f4", + "0x00000000000000000000000000000000000000000000000000000000000006f5", + "0x00000000000000000000000000000000000000000000000000000000000006f6", + "0x00000000000000000000000000000000000000000000000000000000000006f7", + "0x00000000000000000000000000000000000000000000000000000000000006f8", + "0x00000000000000000000000000000000000000000000000000000000000006f9", + "0x00000000000000000000000000000000000000000000000000000000000006fa", + "0x00000000000000000000000000000000000000000000000000000000000006fb", + "0x00000000000000000000000000000000000000000000000000000000000006fc", + "0x00000000000000000000000000000000000000000000000000000000000006fd", + "0x00000000000000000000000000000000000000000000000000000000000006fe", + "0x00000000000000000000000000000000000000000000000000000000000006ff", + "0x0000000000000000000000000000000000000000000000000000000000000700", + "0x0000000000000000000000000000000000000000000000000000000000000701", + "0x0000000000000000000000000000000000000000000000000000000000000702", + "0x0000000000000000000000000000000000000000000000000000000000000703", + "0x0000000000000000000000000000000000000000000000000000000000000704", + "0x0000000000000000000000000000000000000000000000000000000000000705", + "0x0000000000000000000000000000000000000000000000000000000000000706", + "0x0000000000000000000000000000000000000000000000000000000000000707", + "0x0000000000000000000000000000000000000000000000000000000000000708", + "0x0000000000000000000000000000000000000000000000000000000000000709", + "0x000000000000000000000000000000000000000000000000000000000000070a", + "0x000000000000000000000000000000000000000000000000000000000000070b", + "0x000000000000000000000000000000000000000000000000000000000000070c", + "0x000000000000000000000000000000000000000000000000000000000000070d", + "0x000000000000000000000000000000000000000000000000000000000000070e", + "0x000000000000000000000000000000000000000000000000000000000000070f", + "0x0000000000000000000000000000000000000000000000000000000000000710", + "0x0000000000000000000000000000000000000000000000000000000000000711", + "0x0000000000000000000000000000000000000000000000000000000000000712", + "0x0000000000000000000000000000000000000000000000000000000000000713", + "0x0000000000000000000000000000000000000000000000000000000000000714", + "0x0000000000000000000000000000000000000000000000000000000000000715", + "0x0000000000000000000000000000000000000000000000000000000000000716", + "0x0000000000000000000000000000000000000000000000000000000000000717", + "0x0000000000000000000000000000000000000000000000000000000000000718", + "0x0000000000000000000000000000000000000000000000000000000000000719", + "0x000000000000000000000000000000000000000000000000000000000000071a", + "0x000000000000000000000000000000000000000000000000000000000000071b", + "0x000000000000000000000000000000000000000000000000000000000000071c", + "0x000000000000000000000000000000000000000000000000000000000000071d", + "0x000000000000000000000000000000000000000000000000000000000000071e", + "0x000000000000000000000000000000000000000000000000000000000000071f", + "0x0000000000000000000000000000000000000000000000000000000000000720", + "0x0000000000000000000000000000000000000000000000000000000000000721", + "0x0000000000000000000000000000000000000000000000000000000000000722", + "0x0000000000000000000000000000000000000000000000000000000000000723", + "0x0000000000000000000000000000000000000000000000000000000000000724", + "0x0000000000000000000000000000000000000000000000000000000000000725", + "0x0000000000000000000000000000000000000000000000000000000000000726", + "0x0000000000000000000000000000000000000000000000000000000000000727", + "0x0000000000000000000000000000000000000000000000000000000000000728", + "0x0000000000000000000000000000000000000000000000000000000000000729", + "0x000000000000000000000000000000000000000000000000000000000000072a", + "0x000000000000000000000000000000000000000000000000000000000000072b", + "0x000000000000000000000000000000000000000000000000000000000000072c", + "0x000000000000000000000000000000000000000000000000000000000000072d", + "0x000000000000000000000000000000000000000000000000000000000000072e", + "0x000000000000000000000000000000000000000000000000000000000000072f", + "0x0000000000000000000000000000000000000000000000000000000000000730", + "0x0000000000000000000000000000000000000000000000000000000000000731", + "0x0000000000000000000000000000000000000000000000000000000000000732", + "0x0000000000000000000000000000000000000000000000000000000000000733", + "0x0000000000000000000000000000000000000000000000000000000000000734", + "0x0000000000000000000000000000000000000000000000000000000000000735", + "0x0000000000000000000000000000000000000000000000000000000000000736", + "0x0000000000000000000000000000000000000000000000000000000000000737", + "0x0000000000000000000000000000000000000000000000000000000000000738", + "0x0000000000000000000000000000000000000000000000000000000000000739", + "0x000000000000000000000000000000000000000000000000000000000000073a", + "0x000000000000000000000000000000000000000000000000000000000000073b", + "0x000000000000000000000000000000000000000000000000000000000000073c", + "0x000000000000000000000000000000000000000000000000000000000000073d", + "0x000000000000000000000000000000000000000000000000000000000000073e", + "0x000000000000000000000000000000000000000000000000000000000000073f", + "0x0000000000000000000000000000000000000000000000000000000000000740", + "0x0000000000000000000000000000000000000000000000000000000000000741", + "0x0000000000000000000000000000000000000000000000000000000000000742", + "0x0000000000000000000000000000000000000000000000000000000000000743", + "0x0000000000000000000000000000000000000000000000000000000000000744", + "0x0000000000000000000000000000000000000000000000000000000000000745", + "0x0000000000000000000000000000000000000000000000000000000000000746", + "0x0000000000000000000000000000000000000000000000000000000000000747", + "0x0000000000000000000000000000000000000000000000000000000000000748", + "0x0000000000000000000000000000000000000000000000000000000000000749", + "0x000000000000000000000000000000000000000000000000000000000000074a", + "0x000000000000000000000000000000000000000000000000000000000000074b", + "0x000000000000000000000000000000000000000000000000000000000000074c", + "0x000000000000000000000000000000000000000000000000000000000000074d", + "0x000000000000000000000000000000000000000000000000000000000000074e", + "0x000000000000000000000000000000000000000000000000000000000000074f", + "0x0000000000000000000000000000000000000000000000000000000000000750", + "0x0000000000000000000000000000000000000000000000000000000000000751", + "0x0000000000000000000000000000000000000000000000000000000000000752", + "0x0000000000000000000000000000000000000000000000000000000000000753", + "0x0000000000000000000000000000000000000000000000000000000000000754", + "0x0000000000000000000000000000000000000000000000000000000000000755", + "0x0000000000000000000000000000000000000000000000000000000000000756", + "0x0000000000000000000000000000000000000000000000000000000000000757", + "0x0000000000000000000000000000000000000000000000000000000000000758", + "0x0000000000000000000000000000000000000000000000000000000000000759", + "0x000000000000000000000000000000000000000000000000000000000000075a", + "0x000000000000000000000000000000000000000000000000000000000000075b", + "0x000000000000000000000000000000000000000000000000000000000000075c", + "0x000000000000000000000000000000000000000000000000000000000000075d", + "0x000000000000000000000000000000000000000000000000000000000000075e", + "0x000000000000000000000000000000000000000000000000000000000000075f", + "0x0000000000000000000000000000000000000000000000000000000000000760", + "0x0000000000000000000000000000000000000000000000000000000000000761", + "0x0000000000000000000000000000000000000000000000000000000000000762", + "0x0000000000000000000000000000000000000000000000000000000000000763", + "0x0000000000000000000000000000000000000000000000000000000000000764", + "0x0000000000000000000000000000000000000000000000000000000000000765", + "0x0000000000000000000000000000000000000000000000000000000000000766", + "0x0000000000000000000000000000000000000000000000000000000000000767", + "0x0000000000000000000000000000000000000000000000000000000000000768", + "0x0000000000000000000000000000000000000000000000000000000000000769", + "0x000000000000000000000000000000000000000000000000000000000000076a", + "0x000000000000000000000000000000000000000000000000000000000000076b", + "0x000000000000000000000000000000000000000000000000000000000000076c", + "0x000000000000000000000000000000000000000000000000000000000000076d", + "0x000000000000000000000000000000000000000000000000000000000000076e", + "0x000000000000000000000000000000000000000000000000000000000000076f", + "0x0000000000000000000000000000000000000000000000000000000000000770", + "0x0000000000000000000000000000000000000000000000000000000000000771", + "0x0000000000000000000000000000000000000000000000000000000000000772", + "0x0000000000000000000000000000000000000000000000000000000000000773", + "0x0000000000000000000000000000000000000000000000000000000000000774", + "0x0000000000000000000000000000000000000000000000000000000000000775", + "0x0000000000000000000000000000000000000000000000000000000000000776", + "0x0000000000000000000000000000000000000000000000000000000000000777", + "0x0000000000000000000000000000000000000000000000000000000000000778", + "0x0000000000000000000000000000000000000000000000000000000000000779", + "0x000000000000000000000000000000000000000000000000000000000000077a", + "0x000000000000000000000000000000000000000000000000000000000000077b", + "0x000000000000000000000000000000000000000000000000000000000000077c", + "0x000000000000000000000000000000000000000000000000000000000000077d", + "0x000000000000000000000000000000000000000000000000000000000000077e", + "0x000000000000000000000000000000000000000000000000000000000000077f", + "0x0000000000000000000000000000000000000000000000000000000000000780", + "0x0000000000000000000000000000000000000000000000000000000000000781", + "0x0000000000000000000000000000000000000000000000000000000000000782", + "0x0000000000000000000000000000000000000000000000000000000000000783", + "0x0000000000000000000000000000000000000000000000000000000000000784", + "0x0000000000000000000000000000000000000000000000000000000000000785", + "0x0000000000000000000000000000000000000000000000000000000000000786", + "0x0000000000000000000000000000000000000000000000000000000000000787", + "0x0000000000000000000000000000000000000000000000000000000000000788", + "0x0000000000000000000000000000000000000000000000000000000000000789", + "0x000000000000000000000000000000000000000000000000000000000000078a", + "0x000000000000000000000000000000000000000000000000000000000000078b", + "0x000000000000000000000000000000000000000000000000000000000000078c", + "0x000000000000000000000000000000000000000000000000000000000000078d", + "0x000000000000000000000000000000000000000000000000000000000000078e", + "0x000000000000000000000000000000000000000000000000000000000000078f", + "0x0000000000000000000000000000000000000000000000000000000000000790", + "0x0000000000000000000000000000000000000000000000000000000000000791", + "0x0000000000000000000000000000000000000000000000000000000000000792", + "0x0000000000000000000000000000000000000000000000000000000000000793", + "0x0000000000000000000000000000000000000000000000000000000000000794", + "0x0000000000000000000000000000000000000000000000000000000000000795", + "0x0000000000000000000000000000000000000000000000000000000000000796", + "0x0000000000000000000000000000000000000000000000000000000000000797", + "0x0000000000000000000000000000000000000000000000000000000000000798", + "0x0000000000000000000000000000000000000000000000000000000000000799", + "0x000000000000000000000000000000000000000000000000000000000000079a", + "0x000000000000000000000000000000000000000000000000000000000000079b", + "0x000000000000000000000000000000000000000000000000000000000000079c", + "0x000000000000000000000000000000000000000000000000000000000000079d", + "0x000000000000000000000000000000000000000000000000000000000000079e", + "0x000000000000000000000000000000000000000000000000000000000000079f", + "0x00000000000000000000000000000000000000000000000000000000000007a0", + "0x00000000000000000000000000000000000000000000000000000000000007a1", + "0x00000000000000000000000000000000000000000000000000000000000007a2", + "0x00000000000000000000000000000000000000000000000000000000000007a3", + "0x00000000000000000000000000000000000000000000000000000000000007a4", + "0x00000000000000000000000000000000000000000000000000000000000007a5", + "0x00000000000000000000000000000000000000000000000000000000000007a6", + "0x00000000000000000000000000000000000000000000000000000000000007a7", + "0x00000000000000000000000000000000000000000000000000000000000007a8", + "0x00000000000000000000000000000000000000000000000000000000000007a9", + "0x00000000000000000000000000000000000000000000000000000000000007aa", + "0x00000000000000000000000000000000000000000000000000000000000007ab", + "0x00000000000000000000000000000000000000000000000000000000000007ac", + "0x00000000000000000000000000000000000000000000000000000000000007ad", + "0x00000000000000000000000000000000000000000000000000000000000007ae", + "0x00000000000000000000000000000000000000000000000000000000000007af", + "0x00000000000000000000000000000000000000000000000000000000000007b0", + "0x00000000000000000000000000000000000000000000000000000000000007b1", + "0x00000000000000000000000000000000000000000000000000000000000007b2", + "0x00000000000000000000000000000000000000000000000000000000000007b3", + "0x00000000000000000000000000000000000000000000000000000000000007b4", + "0x00000000000000000000000000000000000000000000000000000000000007b5", + "0x00000000000000000000000000000000000000000000000000000000000007b6", + "0x00000000000000000000000000000000000000000000000000000000000007b7", + "0x00000000000000000000000000000000000000000000000000000000000007b8", + "0x00000000000000000000000000000000000000000000000000000000000007b9", + "0x00000000000000000000000000000000000000000000000000000000000007ba", + "0x00000000000000000000000000000000000000000000000000000000000007bb", + "0x00000000000000000000000000000000000000000000000000000000000007bc", + "0x00000000000000000000000000000000000000000000000000000000000007bd", + "0x00000000000000000000000000000000000000000000000000000000000007be", + "0x00000000000000000000000000000000000000000000000000000000000007bf", + "0x00000000000000000000000000000000000000000000000000000000000007c0", + "0x00000000000000000000000000000000000000000000000000000000000007c1", + "0x00000000000000000000000000000000000000000000000000000000000007c2", + "0x00000000000000000000000000000000000000000000000000000000000007c3", + "0x00000000000000000000000000000000000000000000000000000000000007c4", + "0x00000000000000000000000000000000000000000000000000000000000007c5", + "0x00000000000000000000000000000000000000000000000000000000000007c6", + "0x00000000000000000000000000000000000000000000000000000000000007c7", + "0x00000000000000000000000000000000000000000000000000000000000007c8", + "0x00000000000000000000000000000000000000000000000000000000000007c9", + "0x00000000000000000000000000000000000000000000000000000000000007ca", + "0x00000000000000000000000000000000000000000000000000000000000007cb", + "0x00000000000000000000000000000000000000000000000000000000000007cc", + "0x00000000000000000000000000000000000000000000000000000000000007cd", + "0x00000000000000000000000000000000000000000000000000000000000007ce", + "0x00000000000000000000000000000000000000000000000000000000000007cf", + "0x00000000000000000000000000000000000000000000000000000000000007d0", + "0x00000000000000000000000000000000000000000000000000000000000007d1", + "0x00000000000000000000000000000000000000000000000000000000000007d2", + "0x00000000000000000000000000000000000000000000000000000000000007d3", + "0x00000000000000000000000000000000000000000000000000000000000007d4", + "0x00000000000000000000000000000000000000000000000000000000000007d5", + "0x00000000000000000000000000000000000000000000000000000000000007d6", + "0x00000000000000000000000000000000000000000000000000000000000007d7", + "0x00000000000000000000000000000000000000000000000000000000000007d8", + "0x00000000000000000000000000000000000000000000000000000000000007d9", + "0x00000000000000000000000000000000000000000000000000000000000007da", + "0x00000000000000000000000000000000000000000000000000000000000007db", + "0x00000000000000000000000000000000000000000000000000000000000007dc", + "0x00000000000000000000000000000000000000000000000000000000000007dd", + "0x00000000000000000000000000000000000000000000000000000000000007de", + "0x00000000000000000000000000000000000000000000000000000000000007df", + "0x00000000000000000000000000000000000000000000000000000000000007e0", + "0x00000000000000000000000000000000000000000000000000000000000007e1", + "0x00000000000000000000000000000000000000000000000000000000000007e2", + "0x00000000000000000000000000000000000000000000000000000000000007e3", + "0x00000000000000000000000000000000000000000000000000000000000007e4", + "0x00000000000000000000000000000000000000000000000000000000000007e5", + "0x00000000000000000000000000000000000000000000000000000000000007e6", + "0x00000000000000000000000000000000000000000000000000000000000007e7", + "0x00000000000000000000000000000000000000000000000000000000000007e8", + "0x00000000000000000000000000000000000000000000000000000000000007e9", + "0x00000000000000000000000000000000000000000000000000000000000007ea", + "0x00000000000000000000000000000000000000000000000000000000000007eb", + "0x00000000000000000000000000000000000000000000000000000000000007ec", + "0x00000000000000000000000000000000000000000000000000000000000007ed", + "0x00000000000000000000000000000000000000000000000000000000000007ee", + "0x00000000000000000000000000000000000000000000000000000000000007ef", + "0x00000000000000000000000000000000000000000000000000000000000007f0", + "0x00000000000000000000000000000000000000000000000000000000000007f1", + "0x00000000000000000000000000000000000000000000000000000000000007f2", + "0x00000000000000000000000000000000000000000000000000000000000007f3", + "0x00000000000000000000000000000000000000000000000000000000000007f4", + "0x00000000000000000000000000000000000000000000000000000000000007f5", + "0x00000000000000000000000000000000000000000000000000000000000007f6", + "0x00000000000000000000000000000000000000000000000000000000000007f7", + "0x00000000000000000000000000000000000000000000000000000000000007f8", + "0x00000000000000000000000000000000000000000000000000000000000007f9", + "0x00000000000000000000000000000000000000000000000000000000000007fa", + "0x00000000000000000000000000000000000000000000000000000000000007fb", + "0x00000000000000000000000000000000000000000000000000000000000007fc", + "0x00000000000000000000000000000000000000000000000000000000000007fd", + "0x00000000000000000000000000000000000000000000000000000000000007fe", + "0x00000000000000000000000000000000000000000000000000000000000007ff", + "0x0000000000000000000000000000000000000000000000000000000000000800", + "0x0000000000000000000000000000000000000000000000000000000000000801", + "0x0000000000000000000000000000000000000000000000000000000000000802", + "0x0000000000000000000000000000000000000000000000000000000000000803", + "0x0000000000000000000000000000000000000000000000000000000000000804", + "0x0000000000000000000000000000000000000000000000000000000000000805", + "0x0000000000000000000000000000000000000000000000000000000000000806", + "0x0000000000000000000000000000000000000000000000000000000000000807", + "0x0000000000000000000000000000000000000000000000000000000000000808", + "0x0000000000000000000000000000000000000000000000000000000000000809", + "0x000000000000000000000000000000000000000000000000000000000000080a", + "0x000000000000000000000000000000000000000000000000000000000000080b", + "0x000000000000000000000000000000000000000000000000000000000000080c", + "0x000000000000000000000000000000000000000000000000000000000000080d", + "0x000000000000000000000000000000000000000000000000000000000000080e", + "0x000000000000000000000000000000000000000000000000000000000000080f", + "0x0000000000000000000000000000000000000000000000000000000000000810", + "0x0000000000000000000000000000000000000000000000000000000000000811", + "0x0000000000000000000000000000000000000000000000000000000000000812", + "0x0000000000000000000000000000000000000000000000000000000000000813", + "0x0000000000000000000000000000000000000000000000000000000000000814", + "0x0000000000000000000000000000000000000000000000000000000000000815", + "0x0000000000000000000000000000000000000000000000000000000000000816", + "0x0000000000000000000000000000000000000000000000000000000000000817", + "0x0000000000000000000000000000000000000000000000000000000000000818", + "0x0000000000000000000000000000000000000000000000000000000000000819", + "0x000000000000000000000000000000000000000000000000000000000000081a", + "0x000000000000000000000000000000000000000000000000000000000000081b", + "0x000000000000000000000000000000000000000000000000000000000000081c", + "0x000000000000000000000000000000000000000000000000000000000000081d", + "0x000000000000000000000000000000000000000000000000000000000000081e", + "0x000000000000000000000000000000000000000000000000000000000000081f", + "0x0000000000000000000000000000000000000000000000000000000000000820", + "0x0000000000000000000000000000000000000000000000000000000000000821", + "0x0000000000000000000000000000000000000000000000000000000000000822", + "0x0000000000000000000000000000000000000000000000000000000000000823", + "0x0000000000000000000000000000000000000000000000000000000000000824", + "0x0000000000000000000000000000000000000000000000000000000000000825", + "0x0000000000000000000000000000000000000000000000000000000000000826", + "0x0000000000000000000000000000000000000000000000000000000000000827", + "0x0000000000000000000000000000000000000000000000000000000000000828", + "0x0000000000000000000000000000000000000000000000000000000000000829", + "0x000000000000000000000000000000000000000000000000000000000000082a", + "0x000000000000000000000000000000000000000000000000000000000000082b", + "0x000000000000000000000000000000000000000000000000000000000000082c", + "0x000000000000000000000000000000000000000000000000000000000000082d", + "0x000000000000000000000000000000000000000000000000000000000000082e", + "0x000000000000000000000000000000000000000000000000000000000000082f", + "0x0000000000000000000000000000000000000000000000000000000000000830", + "0x0000000000000000000000000000000000000000000000000000000000000831", + "0x0000000000000000000000000000000000000000000000000000000000000832", + "0x0000000000000000000000000000000000000000000000000000000000000833", + "0x0000000000000000000000000000000000000000000000000000000000000834", + "0x0000000000000000000000000000000000000000000000000000000000000835", + "0x0000000000000000000000000000000000000000000000000000000000000836", + "0x0000000000000000000000000000000000000000000000000000000000000837", + "0x0000000000000000000000000000000000000000000000000000000000000838", + "0x0000000000000000000000000000000000000000000000000000000000000839", + "0x000000000000000000000000000000000000000000000000000000000000083a", + "0x000000000000000000000000000000000000000000000000000000000000083b", + "0x000000000000000000000000000000000000000000000000000000000000083c", + "0x000000000000000000000000000000000000000000000000000000000000083d", + "0x000000000000000000000000000000000000000000000000000000000000083e", + "0x000000000000000000000000000000000000000000000000000000000000083f", + "0x0000000000000000000000000000000000000000000000000000000000000840", + "0x0000000000000000000000000000000000000000000000000000000000000841", + "0x0000000000000000000000000000000000000000000000000000000000000842", + "0x0000000000000000000000000000000000000000000000000000000000000843", + "0x0000000000000000000000000000000000000000000000000000000000000844", + "0x0000000000000000000000000000000000000000000000000000000000000845", + "0x0000000000000000000000000000000000000000000000000000000000000846", + "0x0000000000000000000000000000000000000000000000000000000000000847", + "0x0000000000000000000000000000000000000000000000000000000000000848", + "0x0000000000000000000000000000000000000000000000000000000000000849", + "0x000000000000000000000000000000000000000000000000000000000000084a", + "0x000000000000000000000000000000000000000000000000000000000000084b", + "0x000000000000000000000000000000000000000000000000000000000000084c", + "0x000000000000000000000000000000000000000000000000000000000000084d", + "0x000000000000000000000000000000000000000000000000000000000000084e", + "0x000000000000000000000000000000000000000000000000000000000000084f", + "0x0000000000000000000000000000000000000000000000000000000000000850", + "0x0000000000000000000000000000000000000000000000000000000000000851", + "0x0000000000000000000000000000000000000000000000000000000000000852", + "0x0000000000000000000000000000000000000000000000000000000000000853", + "0x0000000000000000000000000000000000000000000000000000000000000854", + "0x0000000000000000000000000000000000000000000000000000000000000855", + "0x0000000000000000000000000000000000000000000000000000000000000856", + "0x0000000000000000000000000000000000000000000000000000000000000857", + "0x0000000000000000000000000000000000000000000000000000000000000858", + "0x0000000000000000000000000000000000000000000000000000000000000859", + "0x000000000000000000000000000000000000000000000000000000000000085a", + "0x000000000000000000000000000000000000000000000000000000000000085b", + "0x000000000000000000000000000000000000000000000000000000000000085c", + "0x000000000000000000000000000000000000000000000000000000000000085d", + "0x000000000000000000000000000000000000000000000000000000000000085e", + "0x000000000000000000000000000000000000000000000000000000000000085f", + "0x0000000000000000000000000000000000000000000000000000000000000860", + "0x0000000000000000000000000000000000000000000000000000000000000861", + "0x0000000000000000000000000000000000000000000000000000000000000862", + "0x0000000000000000000000000000000000000000000000000000000000000863", + "0x0000000000000000000000000000000000000000000000000000000000000864", + "0x0000000000000000000000000000000000000000000000000000000000000865", + "0x0000000000000000000000000000000000000000000000000000000000000866", + "0x0000000000000000000000000000000000000000000000000000000000000867", + "0x0000000000000000000000000000000000000000000000000000000000000868", + "0x0000000000000000000000000000000000000000000000000000000000000869", + "0x000000000000000000000000000000000000000000000000000000000000086a", + "0x000000000000000000000000000000000000000000000000000000000000086b", + "0x000000000000000000000000000000000000000000000000000000000000086c", + "0x000000000000000000000000000000000000000000000000000000000000086d", + "0x000000000000000000000000000000000000000000000000000000000000086e", + "0x000000000000000000000000000000000000000000000000000000000000086f", + "0x0000000000000000000000000000000000000000000000000000000000000870", + "0x0000000000000000000000000000000000000000000000000000000000000871", + "0x0000000000000000000000000000000000000000000000000000000000000872", + "0x0000000000000000000000000000000000000000000000000000000000000873", + "0x0000000000000000000000000000000000000000000000000000000000000874", + "0x0000000000000000000000000000000000000000000000000000000000000875", + "0x0000000000000000000000000000000000000000000000000000000000000876", + "0x0000000000000000000000000000000000000000000000000000000000000877", + "0x0000000000000000000000000000000000000000000000000000000000000878", + "0x0000000000000000000000000000000000000000000000000000000000000879", + "0x000000000000000000000000000000000000000000000000000000000000087a", + "0x000000000000000000000000000000000000000000000000000000000000087b", + "0x000000000000000000000000000000000000000000000000000000000000087c", + "0x000000000000000000000000000000000000000000000000000000000000087d", + "0x000000000000000000000000000000000000000000000000000000000000087e", + "0x000000000000000000000000000000000000000000000000000000000000087f", + "0x0000000000000000000000000000000000000000000000000000000000000880", + "0x0000000000000000000000000000000000000000000000000000000000000881", + "0x0000000000000000000000000000000000000000000000000000000000000882", + "0x0000000000000000000000000000000000000000000000000000000000000883", + "0x0000000000000000000000000000000000000000000000000000000000000884", + "0x0000000000000000000000000000000000000000000000000000000000000885", + "0x0000000000000000000000000000000000000000000000000000000000000886", + "0x0000000000000000000000000000000000000000000000000000000000000887", + "0x0000000000000000000000000000000000000000000000000000000000000888", + "0x0000000000000000000000000000000000000000000000000000000000000889", + "0x000000000000000000000000000000000000000000000000000000000000088a", + "0x000000000000000000000000000000000000000000000000000000000000088b", + "0x000000000000000000000000000000000000000000000000000000000000088c", + "0x000000000000000000000000000000000000000000000000000000000000088d", + "0x000000000000000000000000000000000000000000000000000000000000088e", + "0x000000000000000000000000000000000000000000000000000000000000088f", + "0x0000000000000000000000000000000000000000000000000000000000000890", + "0x0000000000000000000000000000000000000000000000000000000000000891", + "0x0000000000000000000000000000000000000000000000000000000000000892", + "0x0000000000000000000000000000000000000000000000000000000000000893", + "0x0000000000000000000000000000000000000000000000000000000000000894", + "0x0000000000000000000000000000000000000000000000000000000000000895", + "0x0000000000000000000000000000000000000000000000000000000000000896", + "0x0000000000000000000000000000000000000000000000000000000000000897", + "0x0000000000000000000000000000000000000000000000000000000000000898", + "0x0000000000000000000000000000000000000000000000000000000000000899", + "0x000000000000000000000000000000000000000000000000000000000000089a", + "0x000000000000000000000000000000000000000000000000000000000000089b", + "0x000000000000000000000000000000000000000000000000000000000000089c", + "0x000000000000000000000000000000000000000000000000000000000000089d", + "0x000000000000000000000000000000000000000000000000000000000000089e", + "0x000000000000000000000000000000000000000000000000000000000000089f", + "0x00000000000000000000000000000000000000000000000000000000000008a0", + "0x00000000000000000000000000000000000000000000000000000000000008a1", + "0x00000000000000000000000000000000000000000000000000000000000008a2", + "0x00000000000000000000000000000000000000000000000000000000000008a3", + "0x00000000000000000000000000000000000000000000000000000000000008a4", + "0x00000000000000000000000000000000000000000000000000000000000008a5", + "0x00000000000000000000000000000000000000000000000000000000000008a6", + "0x00000000000000000000000000000000000000000000000000000000000008a7", + "0x00000000000000000000000000000000000000000000000000000000000008a8", + "0x00000000000000000000000000000000000000000000000000000000000008a9", + "0x00000000000000000000000000000000000000000000000000000000000008aa", + "0x00000000000000000000000000000000000000000000000000000000000008ab", + "0x00000000000000000000000000000000000000000000000000000000000008ac", + "0x00000000000000000000000000000000000000000000000000000000000008ad", + "0x00000000000000000000000000000000000000000000000000000000000008ae", + "0x00000000000000000000000000000000000000000000000000000000000008af", + "0x00000000000000000000000000000000000000000000000000000000000008b0", + "0x00000000000000000000000000000000000000000000000000000000000008b1", + "0x00000000000000000000000000000000000000000000000000000000000008b2", + "0x00000000000000000000000000000000000000000000000000000000000008b3", + "0x00000000000000000000000000000000000000000000000000000000000008b4", + "0x00000000000000000000000000000000000000000000000000000000000008b5", + "0x00000000000000000000000000000000000000000000000000000000000008b6", + "0x00000000000000000000000000000000000000000000000000000000000008b7", + "0x00000000000000000000000000000000000000000000000000000000000008b8", + "0x00000000000000000000000000000000000000000000000000000000000008b9", + "0x00000000000000000000000000000000000000000000000000000000000008ba", + "0x00000000000000000000000000000000000000000000000000000000000008bb", + "0x00000000000000000000000000000000000000000000000000000000000008bc", + "0x00000000000000000000000000000000000000000000000000000000000008bd", + "0x00000000000000000000000000000000000000000000000000000000000008be", + "0x00000000000000000000000000000000000000000000000000000000000008bf", + "0x00000000000000000000000000000000000000000000000000000000000008c0", + "0x00000000000000000000000000000000000000000000000000000000000008c1", + "0x00000000000000000000000000000000000000000000000000000000000008c2", + "0x00000000000000000000000000000000000000000000000000000000000008c3", + "0x00000000000000000000000000000000000000000000000000000000000008c4", + "0x00000000000000000000000000000000000000000000000000000000000008c5", + "0x00000000000000000000000000000000000000000000000000000000000008c6", + "0x00000000000000000000000000000000000000000000000000000000000008c7", + "0x00000000000000000000000000000000000000000000000000000000000008c8", + "0x00000000000000000000000000000000000000000000000000000000000008c9", + "0x00000000000000000000000000000000000000000000000000000000000008ca", + "0x00000000000000000000000000000000000000000000000000000000000008cb", + "0x00000000000000000000000000000000000000000000000000000000000008cc", + "0x00000000000000000000000000000000000000000000000000000000000008cd", + "0x00000000000000000000000000000000000000000000000000000000000008ce", + "0x00000000000000000000000000000000000000000000000000000000000008cf", + "0x00000000000000000000000000000000000000000000000000000000000008d0", + "0x00000000000000000000000000000000000000000000000000000000000008d1", + "0x00000000000000000000000000000000000000000000000000000000000008d2", + "0x00000000000000000000000000000000000000000000000000000000000008d3", + "0x00000000000000000000000000000000000000000000000000000000000008d4", + "0x00000000000000000000000000000000000000000000000000000000000008d5", + "0x00000000000000000000000000000000000000000000000000000000000008d6", + "0x00000000000000000000000000000000000000000000000000000000000008d7", + "0x00000000000000000000000000000000000000000000000000000000000008d8", + "0x00000000000000000000000000000000000000000000000000000000000008d9", + "0x00000000000000000000000000000000000000000000000000000000000008da", + "0x00000000000000000000000000000000000000000000000000000000000008db", + "0x00000000000000000000000000000000000000000000000000000000000008dc", + "0x00000000000000000000000000000000000000000000000000000000000008dd", + "0x00000000000000000000000000000000000000000000000000000000000008de", + "0x00000000000000000000000000000000000000000000000000000000000008df", + "0x00000000000000000000000000000000000000000000000000000000000008e0", + "0x00000000000000000000000000000000000000000000000000000000000008e1", + "0x00000000000000000000000000000000000000000000000000000000000008e2", + "0x00000000000000000000000000000000000000000000000000000000000008e3", + "0x00000000000000000000000000000000000000000000000000000000000008e4", + "0x00000000000000000000000000000000000000000000000000000000000008e5", + "0x00000000000000000000000000000000000000000000000000000000000008e6", + "0x00000000000000000000000000000000000000000000000000000000000008e7", + "0x00000000000000000000000000000000000000000000000000000000000008e8", + "0x00000000000000000000000000000000000000000000000000000000000008e9", + "0x00000000000000000000000000000000000000000000000000000000000008ea", + "0x00000000000000000000000000000000000000000000000000000000000008eb", + "0x00000000000000000000000000000000000000000000000000000000000008ec", + "0x00000000000000000000000000000000000000000000000000000000000008ed", + "0x00000000000000000000000000000000000000000000000000000000000008ee", + "0x00000000000000000000000000000000000000000000000000000000000008ef", + "0x00000000000000000000000000000000000000000000000000000000000008f0", + "0x00000000000000000000000000000000000000000000000000000000000008f1", + "0x00000000000000000000000000000000000000000000000000000000000008f2", + "0x00000000000000000000000000000000000000000000000000000000000008f3", + "0x00000000000000000000000000000000000000000000000000000000000008f4", + "0x00000000000000000000000000000000000000000000000000000000000008f5", + "0x00000000000000000000000000000000000000000000000000000000000008f6", + "0x00000000000000000000000000000000000000000000000000000000000008f7", + "0x00000000000000000000000000000000000000000000000000000000000008f8", + "0x00000000000000000000000000000000000000000000000000000000000008f9", + "0x00000000000000000000000000000000000000000000000000000000000008fa", + "0x00000000000000000000000000000000000000000000000000000000000008fb", + "0x00000000000000000000000000000000000000000000000000000000000008fc", + "0x00000000000000000000000000000000000000000000000000000000000008fd", + "0x00000000000000000000000000000000000000000000000000000000000008fe", + "0x00000000000000000000000000000000000000000000000000000000000008ff", + "0x0000000000000000000000000000000000000000000000000000000000000900", + "0x0000000000000000000000000000000000000000000000000000000000000901", + "0x0000000000000000000000000000000000000000000000000000000000000902", + "0x0000000000000000000000000000000000000000000000000000000000000903", + "0x0000000000000000000000000000000000000000000000000000000000000904", + "0x0000000000000000000000000000000000000000000000000000000000000905", + "0x0000000000000000000000000000000000000000000000000000000000000906", + "0x0000000000000000000000000000000000000000000000000000000000000907", + "0x0000000000000000000000000000000000000000000000000000000000000908", + "0x0000000000000000000000000000000000000000000000000000000000000909", + "0x000000000000000000000000000000000000000000000000000000000000090a", + "0x000000000000000000000000000000000000000000000000000000000000090b", + "0x000000000000000000000000000000000000000000000000000000000000090c", + "0x000000000000000000000000000000000000000000000000000000000000090d", + "0x000000000000000000000000000000000000000000000000000000000000090e", + "0x000000000000000000000000000000000000000000000000000000000000090f", + "0x0000000000000000000000000000000000000000000000000000000000000910", + "0x0000000000000000000000000000000000000000000000000000000000000911", + "0x0000000000000000000000000000000000000000000000000000000000000912", + "0x0000000000000000000000000000000000000000000000000000000000000913", + "0x0000000000000000000000000000000000000000000000000000000000000914", + "0x0000000000000000000000000000000000000000000000000000000000000915", + "0x0000000000000000000000000000000000000000000000000000000000000916", + "0x0000000000000000000000000000000000000000000000000000000000000917", + "0x0000000000000000000000000000000000000000000000000000000000000918", + "0x0000000000000000000000000000000000000000000000000000000000000919", + "0x000000000000000000000000000000000000000000000000000000000000091a", + "0x000000000000000000000000000000000000000000000000000000000000091b", + "0x000000000000000000000000000000000000000000000000000000000000091c", + "0x000000000000000000000000000000000000000000000000000000000000091d", + "0x000000000000000000000000000000000000000000000000000000000000091e", + "0x000000000000000000000000000000000000000000000000000000000000091f", + "0x0000000000000000000000000000000000000000000000000000000000000920", + "0x0000000000000000000000000000000000000000000000000000000000000921", + "0x0000000000000000000000000000000000000000000000000000000000000922", + "0x0000000000000000000000000000000000000000000000000000000000000923", + "0x0000000000000000000000000000000000000000000000000000000000000924", + "0x0000000000000000000000000000000000000000000000000000000000000925", + "0x0000000000000000000000000000000000000000000000000000000000000926", + "0x0000000000000000000000000000000000000000000000000000000000000927", + "0x0000000000000000000000000000000000000000000000000000000000000928", + "0x0000000000000000000000000000000000000000000000000000000000000929", + "0x000000000000000000000000000000000000000000000000000000000000092a", + "0x000000000000000000000000000000000000000000000000000000000000092b", + "0x000000000000000000000000000000000000000000000000000000000000092c", + "0x000000000000000000000000000000000000000000000000000000000000092d", + "0x000000000000000000000000000000000000000000000000000000000000092e", + "0x000000000000000000000000000000000000000000000000000000000000092f", + "0x0000000000000000000000000000000000000000000000000000000000000930", + "0x0000000000000000000000000000000000000000000000000000000000000931", + "0x0000000000000000000000000000000000000000000000000000000000000932", + "0x0000000000000000000000000000000000000000000000000000000000000933", + "0x0000000000000000000000000000000000000000000000000000000000000934", + "0x0000000000000000000000000000000000000000000000000000000000000935", + "0x0000000000000000000000000000000000000000000000000000000000000936", + "0x0000000000000000000000000000000000000000000000000000000000000937", + "0x0000000000000000000000000000000000000000000000000000000000000938", + "0x0000000000000000000000000000000000000000000000000000000000000939", + "0x000000000000000000000000000000000000000000000000000000000000093a", + "0x000000000000000000000000000000000000000000000000000000000000093b", + "0x000000000000000000000000000000000000000000000000000000000000093c", + "0x000000000000000000000000000000000000000000000000000000000000093d", + "0x000000000000000000000000000000000000000000000000000000000000093e", + "0x000000000000000000000000000000000000000000000000000000000000093f", + "0x0000000000000000000000000000000000000000000000000000000000000940", + "0x0000000000000000000000000000000000000000000000000000000000000941", + "0x0000000000000000000000000000000000000000000000000000000000000942", + "0x0000000000000000000000000000000000000000000000000000000000000943", + "0x0000000000000000000000000000000000000000000000000000000000000944", + "0x0000000000000000000000000000000000000000000000000000000000000945", + "0x0000000000000000000000000000000000000000000000000000000000000946", + "0x0000000000000000000000000000000000000000000000000000000000000947", + "0x0000000000000000000000000000000000000000000000000000000000000948", + "0x0000000000000000000000000000000000000000000000000000000000000949", + "0x000000000000000000000000000000000000000000000000000000000000094a", + "0x000000000000000000000000000000000000000000000000000000000000094b", + "0x000000000000000000000000000000000000000000000000000000000000094c", + "0x000000000000000000000000000000000000000000000000000000000000094d", + "0x000000000000000000000000000000000000000000000000000000000000094e", + "0x000000000000000000000000000000000000000000000000000000000000094f", + "0x0000000000000000000000000000000000000000000000000000000000000950", + "0x0000000000000000000000000000000000000000000000000000000000000951", + "0x0000000000000000000000000000000000000000000000000000000000000952", + "0x0000000000000000000000000000000000000000000000000000000000000953", + "0x0000000000000000000000000000000000000000000000000000000000000954", + "0x0000000000000000000000000000000000000000000000000000000000000955", + "0x0000000000000000000000000000000000000000000000000000000000000956", + "0x0000000000000000000000000000000000000000000000000000000000000957", + "0x0000000000000000000000000000000000000000000000000000000000000958", + "0x0000000000000000000000000000000000000000000000000000000000000959", + "0x000000000000000000000000000000000000000000000000000000000000095a", + "0x000000000000000000000000000000000000000000000000000000000000095b", + "0x000000000000000000000000000000000000000000000000000000000000095c", + "0x000000000000000000000000000000000000000000000000000000000000095d", + "0x000000000000000000000000000000000000000000000000000000000000095e", + "0x000000000000000000000000000000000000000000000000000000000000095f", + "0x0000000000000000000000000000000000000000000000000000000000000960", + "0x0000000000000000000000000000000000000000000000000000000000000961", + "0x0000000000000000000000000000000000000000000000000000000000000962", + "0x0000000000000000000000000000000000000000000000000000000000000963", + "0x0000000000000000000000000000000000000000000000000000000000000964", + "0x0000000000000000000000000000000000000000000000000000000000000965", + "0x0000000000000000000000000000000000000000000000000000000000000966", + "0x0000000000000000000000000000000000000000000000000000000000000967", + "0x0000000000000000000000000000000000000000000000000000000000000968", + "0x0000000000000000000000000000000000000000000000000000000000000969", + "0x000000000000000000000000000000000000000000000000000000000000096a", + "0x000000000000000000000000000000000000000000000000000000000000096b", + "0x000000000000000000000000000000000000000000000000000000000000096c", + "0x000000000000000000000000000000000000000000000000000000000000096d", + "0x000000000000000000000000000000000000000000000000000000000000096e", + "0x000000000000000000000000000000000000000000000000000000000000096f", + "0x0000000000000000000000000000000000000000000000000000000000000970", + "0x0000000000000000000000000000000000000000000000000000000000000971", + "0x0000000000000000000000000000000000000000000000000000000000000972", + "0x0000000000000000000000000000000000000000000000000000000000000973", + "0x0000000000000000000000000000000000000000000000000000000000000974", + "0x0000000000000000000000000000000000000000000000000000000000000975", + "0x0000000000000000000000000000000000000000000000000000000000000976", + "0x0000000000000000000000000000000000000000000000000000000000000977", + "0x0000000000000000000000000000000000000000000000000000000000000978", + "0x0000000000000000000000000000000000000000000000000000000000000979", + "0x000000000000000000000000000000000000000000000000000000000000097a", + "0x000000000000000000000000000000000000000000000000000000000000097b", + "0x000000000000000000000000000000000000000000000000000000000000097c", + "0x000000000000000000000000000000000000000000000000000000000000097d", + "0x000000000000000000000000000000000000000000000000000000000000097e", + "0x000000000000000000000000000000000000000000000000000000000000097f", + "0x0000000000000000000000000000000000000000000000000000000000000980", + "0x0000000000000000000000000000000000000000000000000000000000000981", + "0x0000000000000000000000000000000000000000000000000000000000000982", + "0x0000000000000000000000000000000000000000000000000000000000000983", + "0x0000000000000000000000000000000000000000000000000000000000000984", + "0x0000000000000000000000000000000000000000000000000000000000000985", + "0x0000000000000000000000000000000000000000000000000000000000000986", + "0x0000000000000000000000000000000000000000000000000000000000000987", + "0x0000000000000000000000000000000000000000000000000000000000000988", + "0x0000000000000000000000000000000000000000000000000000000000000989", + "0x000000000000000000000000000000000000000000000000000000000000098a", + "0x000000000000000000000000000000000000000000000000000000000000098b", + "0x000000000000000000000000000000000000000000000000000000000000098c", + "0x000000000000000000000000000000000000000000000000000000000000098d", + "0x000000000000000000000000000000000000000000000000000000000000098e", + "0x000000000000000000000000000000000000000000000000000000000000098f", + "0x0000000000000000000000000000000000000000000000000000000000000990", + "0x0000000000000000000000000000000000000000000000000000000000000991", + "0x0000000000000000000000000000000000000000000000000000000000000992", + "0x0000000000000000000000000000000000000000000000000000000000000993", + "0x0000000000000000000000000000000000000000000000000000000000000994", + "0x0000000000000000000000000000000000000000000000000000000000000995", + "0x0000000000000000000000000000000000000000000000000000000000000996", + "0x0000000000000000000000000000000000000000000000000000000000000997", + "0x0000000000000000000000000000000000000000000000000000000000000998", + "0x0000000000000000000000000000000000000000000000000000000000000999", + "0x000000000000000000000000000000000000000000000000000000000000099a", + "0x000000000000000000000000000000000000000000000000000000000000099b", + "0x000000000000000000000000000000000000000000000000000000000000099c", + "0x000000000000000000000000000000000000000000000000000000000000099d", + "0x000000000000000000000000000000000000000000000000000000000000099e", + "0x000000000000000000000000000000000000000000000000000000000000099f", + "0x00000000000000000000000000000000000000000000000000000000000009a0", + "0x00000000000000000000000000000000000000000000000000000000000009a1", + "0x00000000000000000000000000000000000000000000000000000000000009a2", + "0x00000000000000000000000000000000000000000000000000000000000009a3", + "0x00000000000000000000000000000000000000000000000000000000000009a4", + "0x00000000000000000000000000000000000000000000000000000000000009a5", + "0x00000000000000000000000000000000000000000000000000000000000009a6", + "0x00000000000000000000000000000000000000000000000000000000000009a7", + "0x00000000000000000000000000000000000000000000000000000000000009a8", + "0x00000000000000000000000000000000000000000000000000000000000009a9", + "0x00000000000000000000000000000000000000000000000000000000000009aa", + "0x00000000000000000000000000000000000000000000000000000000000009ab", + "0x00000000000000000000000000000000000000000000000000000000000009ac", + "0x00000000000000000000000000000000000000000000000000000000000009ad", + "0x00000000000000000000000000000000000000000000000000000000000009ae", + "0x00000000000000000000000000000000000000000000000000000000000009af", + "0x00000000000000000000000000000000000000000000000000000000000009b0", + "0x00000000000000000000000000000000000000000000000000000000000009b1", + "0x00000000000000000000000000000000000000000000000000000000000009b2", + "0x00000000000000000000000000000000000000000000000000000000000009b3", + "0x00000000000000000000000000000000000000000000000000000000000009b4", + "0x00000000000000000000000000000000000000000000000000000000000009b5", + "0x00000000000000000000000000000000000000000000000000000000000009b6", + "0x00000000000000000000000000000000000000000000000000000000000009b7", + "0x00000000000000000000000000000000000000000000000000000000000009b8", + "0x00000000000000000000000000000000000000000000000000000000000009b9", + "0x00000000000000000000000000000000000000000000000000000000000009ba", + "0x00000000000000000000000000000000000000000000000000000000000009bb", + "0x00000000000000000000000000000000000000000000000000000000000009bc", + "0x00000000000000000000000000000000000000000000000000000000000009bd", + "0x00000000000000000000000000000000000000000000000000000000000009be", + "0x00000000000000000000000000000000000000000000000000000000000009bf", + "0x00000000000000000000000000000000000000000000000000000000000009c0", + "0x00000000000000000000000000000000000000000000000000000000000009c1", + "0x00000000000000000000000000000000000000000000000000000000000009c2", + "0x00000000000000000000000000000000000000000000000000000000000009c3", + "0x00000000000000000000000000000000000000000000000000000000000009c4", + "0x00000000000000000000000000000000000000000000000000000000000009c5", + "0x00000000000000000000000000000000000000000000000000000000000009c6", + "0x00000000000000000000000000000000000000000000000000000000000009c7", + "0x00000000000000000000000000000000000000000000000000000000000009c8", + "0x00000000000000000000000000000000000000000000000000000000000009c9", + "0x00000000000000000000000000000000000000000000000000000000000009ca", + "0x00000000000000000000000000000000000000000000000000000000000009cb", + "0x00000000000000000000000000000000000000000000000000000000000009cc", + "0x00000000000000000000000000000000000000000000000000000000000009cd", + "0x00000000000000000000000000000000000000000000000000000000000009ce", + "0x00000000000000000000000000000000000000000000000000000000000009cf", + "0x00000000000000000000000000000000000000000000000000000000000009d0", + "0x00000000000000000000000000000000000000000000000000000000000009d1", + "0x00000000000000000000000000000000000000000000000000000000000009d2", + "0x00000000000000000000000000000000000000000000000000000000000009d3", + "0x00000000000000000000000000000000000000000000000000000000000009d4", + "0x00000000000000000000000000000000000000000000000000000000000009d5", + "0x00000000000000000000000000000000000000000000000000000000000009d6", + "0x00000000000000000000000000000000000000000000000000000000000009d7", + "0x00000000000000000000000000000000000000000000000000000000000009d8", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da", + "0x00000000000000000000000000000000000000000000000000000000000009db" +] + num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400" + num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400" diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-single-tx/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-single-tx/Prover.toml index c442ddae4801..00d469d40a2b 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-single-tx/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first-single-tx/Prover.toml @@ -1,5 +1,15 @@ [inputs] -new_l1_to_l2_message_subtree_root_sibling_path = [ +l1_to_l2_message_frontier_hint = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f", "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad", "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da", @@ -28,10 +38,10 @@ new_l1_to_l2_message_subtree_root_sibling_path = [ "0x0aced6fe68143f4c7acd16345a8c1bb50c51a0692b760eb48728feb923d90757" ] new_archive_sibling_path = [ - "0x049956c594a170be3bf34aa7c0365893406beb1ac5ee53f9e26797bc0b6c7a56", + "0x03f4c32538d42652fb32a5cb2aee4307443fe38382028580e7aa46e43182df55", "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb", "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d", - "0x09308d0807f5aed64dd43d2014519a161c32f9a52ea75992cc18bec0bcde410e", + "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037", "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da", "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249", "0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f", @@ -60,558 +70,6 @@ new_archive_sibling_path = [ "0x2aad701e57c7069cb4e148d971c0eae9ac7429d7d833c51d87875ead0c5aca3c" ] - [inputs.parity_root] - proof = [ - "0x0000000000000000000000000000000000000000000000000000000000000001", - "0x0000000000000000000000000000000000000000000000000000000000000002", - "0x0000000000000000000000000000000000000000000000000000000000000003", - "0x0000000000000000000000000000000000000000000000000000000000000004", - "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x0000000000000000000000000000000000000000000000000000000000000006", - "0x0000000000000000000000000000000000000000000000000000000000000007", - "0x0000000000000000000000000000000000000000000000000000000000000008", - "0x0000000000000000000000000000000000000000000000000000000000000009", - "0x000000000000000000000000000000000000000000000000000000000000000a", - "0x000000000000000000000000000000000000000000000000000000000000000b", - "0x000000000000000000000000000000000000000000000000000000000000000c", - "0x000000000000000000000000000000000000000000000000000000000000000d", - "0x000000000000000000000000000000000000000000000000000000000000000e", - "0x000000000000000000000000000000000000000000000000000000000000000f", - "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x0000000000000000000000000000000000000000000000000000000000000011", - "0x0000000000000000000000000000000000000000000000000000000000000012", - "0x0000000000000000000000000000000000000000000000000000000000000013", - "0x0000000000000000000000000000000000000000000000000000000000000014", - "0x0000000000000000000000000000000000000000000000000000000000000015", - "0x0000000000000000000000000000000000000000000000000000000000000016", - "0x0000000000000000000000000000000000000000000000000000000000000017", - "0x0000000000000000000000000000000000000000000000000000000000000018", - "0x0000000000000000000000000000000000000000000000000000000000000019", - "0x000000000000000000000000000000000000000000000000000000000000001a", - "0x000000000000000000000000000000000000000000000000000000000000001b", - "0x000000000000000000000000000000000000000000000000000000000000001c", - "0x000000000000000000000000000000000000000000000000000000000000001d", - "0x000000000000000000000000000000000000000000000000000000000000001e", - "0x000000000000000000000000000000000000000000000000000000000000001f", - "0x0000000000000000000000000000000000000000000000000000000000000020", - "0x0000000000000000000000000000000000000000000000000000000000000021", - "0x0000000000000000000000000000000000000000000000000000000000000022", - "0x0000000000000000000000000000000000000000000000000000000000000023", - "0x0000000000000000000000000000000000000000000000000000000000000024", - "0x0000000000000000000000000000000000000000000000000000000000000025", - "0x0000000000000000000000000000000000000000000000000000000000000026", - "0x0000000000000000000000000000000000000000000000000000000000000027", - "0x0000000000000000000000000000000000000000000000000000000000000028", - "0x0000000000000000000000000000000000000000000000000000000000000029", - "0x000000000000000000000000000000000000000000000000000000000000002a", - "0x000000000000000000000000000000000000000000000000000000000000002b", - "0x000000000000000000000000000000000000000000000000000000000000002c", - "0x000000000000000000000000000000000000000000000000000000000000002d", - "0x000000000000000000000000000000000000000000000000000000000000002e", - "0x000000000000000000000000000000000000000000000000000000000000002f", - "0x0000000000000000000000000000000000000000000000000000000000000030", - "0x0000000000000000000000000000000000000000000000000000000000000031", - "0x0000000000000000000000000000000000000000000000000000000000000032", - "0x0000000000000000000000000000000000000000000000000000000000000033", - "0x0000000000000000000000000000000000000000000000000000000000000034", - "0x0000000000000000000000000000000000000000000000000000000000000035", - "0x0000000000000000000000000000000000000000000000000000000000000036", - "0x0000000000000000000000000000000000000000000000000000000000000037", - "0x0000000000000000000000000000000000000000000000000000000000000038", - "0x0000000000000000000000000000000000000000000000000000000000000039", - "0x000000000000000000000000000000000000000000000000000000000000003a", - "0x000000000000000000000000000000000000000000000000000000000000003b", - "0x000000000000000000000000000000000000000000000000000000000000003c", - "0x000000000000000000000000000000000000000000000000000000000000003d", - "0x000000000000000000000000000000000000000000000000000000000000003e", - "0x000000000000000000000000000000000000000000000000000000000000003f", - "0x0000000000000000000000000000000000000000000000000000000000000040", - "0x0000000000000000000000000000000000000000000000000000000000000041", - "0x0000000000000000000000000000000000000000000000000000000000000042", - "0x0000000000000000000000000000000000000000000000000000000000000043", - "0x0000000000000000000000000000000000000000000000000000000000000044", - "0x0000000000000000000000000000000000000000000000000000000000000045", - "0x0000000000000000000000000000000000000000000000000000000000000046", - "0x0000000000000000000000000000000000000000000000000000000000000047", - "0x0000000000000000000000000000000000000000000000000000000000000048", - "0x0000000000000000000000000000000000000000000000000000000000000049", - "0x000000000000000000000000000000000000000000000000000000000000004a", - "0x000000000000000000000000000000000000000000000000000000000000004b", - "0x000000000000000000000000000000000000000000000000000000000000004c", - "0x000000000000000000000000000000000000000000000000000000000000004d", - "0x000000000000000000000000000000000000000000000000000000000000004e", - "0x000000000000000000000000000000000000000000000000000000000000004f", - "0x0000000000000000000000000000000000000000000000000000000000000050", - "0x0000000000000000000000000000000000000000000000000000000000000051", - "0x0000000000000000000000000000000000000000000000000000000000000052", - "0x0000000000000000000000000000000000000000000000000000000000000053", - "0x0000000000000000000000000000000000000000000000000000000000000054", - "0x0000000000000000000000000000000000000000000000000000000000000055", - "0x0000000000000000000000000000000000000000000000000000000000000056", - "0x0000000000000000000000000000000000000000000000000000000000000057", - "0x0000000000000000000000000000000000000000000000000000000000000058", - "0x0000000000000000000000000000000000000000000000000000000000000059", - "0x000000000000000000000000000000000000000000000000000000000000005a", - "0x000000000000000000000000000000000000000000000000000000000000005b", - "0x000000000000000000000000000000000000000000000000000000000000005c", - "0x000000000000000000000000000000000000000000000000000000000000005d", - "0x000000000000000000000000000000000000000000000000000000000000005e", - "0x000000000000000000000000000000000000000000000000000000000000005f", - "0x0000000000000000000000000000000000000000000000000000000000000060", - "0x0000000000000000000000000000000000000000000000000000000000000061", - "0x0000000000000000000000000000000000000000000000000000000000000062", - "0x0000000000000000000000000000000000000000000000000000000000000063", - "0x0000000000000000000000000000000000000000000000000000000000000064", - "0x0000000000000000000000000000000000000000000000000000000000000065", - "0x0000000000000000000000000000000000000000000000000000000000000066", - "0x0000000000000000000000000000000000000000000000000000000000000067", - "0x0000000000000000000000000000000000000000000000000000000000000068", - "0x0000000000000000000000000000000000000000000000000000000000000069", - "0x000000000000000000000000000000000000000000000000000000000000006a", - "0x000000000000000000000000000000000000000000000000000000000000006b", - "0x000000000000000000000000000000000000000000000000000000000000006c", - "0x000000000000000000000000000000000000000000000000000000000000006d", - "0x000000000000000000000000000000000000000000000000000000000000006e", - "0x000000000000000000000000000000000000000000000000000000000000006f", - "0x0000000000000000000000000000000000000000000000000000000000000070", - "0x0000000000000000000000000000000000000000000000000000000000000071", - "0x0000000000000000000000000000000000000000000000000000000000000072", - "0x0000000000000000000000000000000000000000000000000000000000000073", - "0x0000000000000000000000000000000000000000000000000000000000000074", - "0x0000000000000000000000000000000000000000000000000000000000000075", - "0x0000000000000000000000000000000000000000000000000000000000000076", - "0x0000000000000000000000000000000000000000000000000000000000000077", - "0x0000000000000000000000000000000000000000000000000000000000000078", - "0x0000000000000000000000000000000000000000000000000000000000000079", - "0x000000000000000000000000000000000000000000000000000000000000007a", - "0x000000000000000000000000000000000000000000000000000000000000007b", - "0x000000000000000000000000000000000000000000000000000000000000007c", - "0x000000000000000000000000000000000000000000000000000000000000007d", - "0x000000000000000000000000000000000000000000000000000000000000007e", - "0x000000000000000000000000000000000000000000000000000000000000007f", - "0x0000000000000000000000000000000000000000000000000000000000000080", - "0x0000000000000000000000000000000000000000000000000000000000000081", - "0x0000000000000000000000000000000000000000000000000000000000000082", - "0x0000000000000000000000000000000000000000000000000000000000000083", - "0x0000000000000000000000000000000000000000000000000000000000000084", - "0x0000000000000000000000000000000000000000000000000000000000000085", - "0x0000000000000000000000000000000000000000000000000000000000000086", - "0x0000000000000000000000000000000000000000000000000000000000000087", - "0x0000000000000000000000000000000000000000000000000000000000000088", - "0x0000000000000000000000000000000000000000000000000000000000000089", - "0x000000000000000000000000000000000000000000000000000000000000008a", - "0x000000000000000000000000000000000000000000000000000000000000008b", - "0x000000000000000000000000000000000000000000000000000000000000008c", - "0x000000000000000000000000000000000000000000000000000000000000008d", - "0x000000000000000000000000000000000000000000000000000000000000008e", - "0x000000000000000000000000000000000000000000000000000000000000008f", - "0x0000000000000000000000000000000000000000000000000000000000000090", - "0x0000000000000000000000000000000000000000000000000000000000000091", - "0x0000000000000000000000000000000000000000000000000000000000000092", - "0x0000000000000000000000000000000000000000000000000000000000000093", - "0x0000000000000000000000000000000000000000000000000000000000000094", - "0x0000000000000000000000000000000000000000000000000000000000000095", - "0x0000000000000000000000000000000000000000000000000000000000000096", - "0x0000000000000000000000000000000000000000000000000000000000000097", - "0x0000000000000000000000000000000000000000000000000000000000000098", - "0x0000000000000000000000000000000000000000000000000000000000000099", - "0x000000000000000000000000000000000000000000000000000000000000009a", - "0x000000000000000000000000000000000000000000000000000000000000009b", - "0x000000000000000000000000000000000000000000000000000000000000009c", - "0x000000000000000000000000000000000000000000000000000000000000009d", - "0x000000000000000000000000000000000000000000000000000000000000009e", - "0x000000000000000000000000000000000000000000000000000000000000009f", - "0x00000000000000000000000000000000000000000000000000000000000000a0", - "0x00000000000000000000000000000000000000000000000000000000000000a1", - "0x00000000000000000000000000000000000000000000000000000000000000a2", - "0x00000000000000000000000000000000000000000000000000000000000000a3", - "0x00000000000000000000000000000000000000000000000000000000000000a4", - "0x00000000000000000000000000000000000000000000000000000000000000a5", - "0x00000000000000000000000000000000000000000000000000000000000000a6", - "0x00000000000000000000000000000000000000000000000000000000000000a7", - "0x00000000000000000000000000000000000000000000000000000000000000a8", - "0x00000000000000000000000000000000000000000000000000000000000000a9", - "0x00000000000000000000000000000000000000000000000000000000000000aa", - "0x00000000000000000000000000000000000000000000000000000000000000ab", - "0x00000000000000000000000000000000000000000000000000000000000000ac", - "0x00000000000000000000000000000000000000000000000000000000000000ad", - "0x00000000000000000000000000000000000000000000000000000000000000ae", - "0x00000000000000000000000000000000000000000000000000000000000000af", - "0x00000000000000000000000000000000000000000000000000000000000000b0", - "0x00000000000000000000000000000000000000000000000000000000000000b1", - "0x00000000000000000000000000000000000000000000000000000000000000b2", - "0x00000000000000000000000000000000000000000000000000000000000000b3", - "0x00000000000000000000000000000000000000000000000000000000000000b4", - "0x00000000000000000000000000000000000000000000000000000000000000b5", - "0x00000000000000000000000000000000000000000000000000000000000000b6", - "0x00000000000000000000000000000000000000000000000000000000000000b7", - "0x00000000000000000000000000000000000000000000000000000000000000b8", - "0x00000000000000000000000000000000000000000000000000000000000000b9", - "0x00000000000000000000000000000000000000000000000000000000000000ba", - "0x00000000000000000000000000000000000000000000000000000000000000bb", - "0x00000000000000000000000000000000000000000000000000000000000000bc", - "0x00000000000000000000000000000000000000000000000000000000000000bd", - "0x00000000000000000000000000000000000000000000000000000000000000be", - "0x00000000000000000000000000000000000000000000000000000000000000bf", - "0x00000000000000000000000000000000000000000000000000000000000000c0", - "0x00000000000000000000000000000000000000000000000000000000000000c1", - "0x00000000000000000000000000000000000000000000000000000000000000c2", - "0x00000000000000000000000000000000000000000000000000000000000000c3", - "0x00000000000000000000000000000000000000000000000000000000000000c4", - "0x00000000000000000000000000000000000000000000000000000000000000c5", - "0x00000000000000000000000000000000000000000000000000000000000000c6", - "0x00000000000000000000000000000000000000000000000000000000000000c7", - "0x00000000000000000000000000000000000000000000000000000000000000c8", - "0x00000000000000000000000000000000000000000000000000000000000000c9", - "0x00000000000000000000000000000000000000000000000000000000000000ca", - "0x00000000000000000000000000000000000000000000000000000000000000cb", - "0x00000000000000000000000000000000000000000000000000000000000000cc", - "0x00000000000000000000000000000000000000000000000000000000000000cd", - "0x00000000000000000000000000000000000000000000000000000000000000ce", - "0x00000000000000000000000000000000000000000000000000000000000000cf", - "0x00000000000000000000000000000000000000000000000000000000000000d0", - "0x00000000000000000000000000000000000000000000000000000000000000d1", - "0x00000000000000000000000000000000000000000000000000000000000000d2", - "0x00000000000000000000000000000000000000000000000000000000000000d3", - "0x00000000000000000000000000000000000000000000000000000000000000d4", - "0x00000000000000000000000000000000000000000000000000000000000000d5", - "0x00000000000000000000000000000000000000000000000000000000000000d6", - "0x00000000000000000000000000000000000000000000000000000000000000d7", - "0x00000000000000000000000000000000000000000000000000000000000000d8", - "0x00000000000000000000000000000000000000000000000000000000000000d9", - "0x00000000000000000000000000000000000000000000000000000000000000da", - "0x00000000000000000000000000000000000000000000000000000000000000db", - "0x00000000000000000000000000000000000000000000000000000000000000dc", - "0x00000000000000000000000000000000000000000000000000000000000000dd", - "0x00000000000000000000000000000000000000000000000000000000000000de", - "0x00000000000000000000000000000000000000000000000000000000000000df", - "0x00000000000000000000000000000000000000000000000000000000000000e0", - "0x00000000000000000000000000000000000000000000000000000000000000e1", - "0x00000000000000000000000000000000000000000000000000000000000000e2", - "0x00000000000000000000000000000000000000000000000000000000000000e3", - "0x00000000000000000000000000000000000000000000000000000000000000e4", - "0x00000000000000000000000000000000000000000000000000000000000000e5", - "0x00000000000000000000000000000000000000000000000000000000000000e6", - "0x00000000000000000000000000000000000000000000000000000000000000e7", - "0x00000000000000000000000000000000000000000000000000000000000000e8", - "0x00000000000000000000000000000000000000000000000000000000000000e9", - "0x00000000000000000000000000000000000000000000000000000000000000ea", - "0x00000000000000000000000000000000000000000000000000000000000000eb", - "0x00000000000000000000000000000000000000000000000000000000000000ec", - "0x00000000000000000000000000000000000000000000000000000000000000ed", - "0x00000000000000000000000000000000000000000000000000000000000000ee", - "0x00000000000000000000000000000000000000000000000000000000000000ef", - "0x00000000000000000000000000000000000000000000000000000000000000f0", - "0x00000000000000000000000000000000000000000000000000000000000000f1", - "0x00000000000000000000000000000000000000000000000000000000000000f2", - "0x00000000000000000000000000000000000000000000000000000000000000f3", - "0x00000000000000000000000000000000000000000000000000000000000000f4", - "0x00000000000000000000000000000000000000000000000000000000000000f5", - "0x00000000000000000000000000000000000000000000000000000000000000f6", - "0x00000000000000000000000000000000000000000000000000000000000000f7", - "0x00000000000000000000000000000000000000000000000000000000000000f8", - "0x00000000000000000000000000000000000000000000000000000000000000f9", - "0x00000000000000000000000000000000000000000000000000000000000000fa", - "0x00000000000000000000000000000000000000000000000000000000000000fb", - "0x00000000000000000000000000000000000000000000000000000000000000fc", - "0x00000000000000000000000000000000000000000000000000000000000000fd", - "0x00000000000000000000000000000000000000000000000000000000000000fe", - "0x00000000000000000000000000000000000000000000000000000000000000ff", - "0x0000000000000000000000000000000000000000000000000000000000000100", - "0x0000000000000000000000000000000000000000000000000000000000000101", - "0x0000000000000000000000000000000000000000000000000000000000000102", - "0x0000000000000000000000000000000000000000000000000000000000000103", - "0x0000000000000000000000000000000000000000000000000000000000000104", - "0x0000000000000000000000000000000000000000000000000000000000000105", - "0x0000000000000000000000000000000000000000000000000000000000000106", - "0x0000000000000000000000000000000000000000000000000000000000000107", - "0x0000000000000000000000000000000000000000000000000000000000000108", - "0x0000000000000000000000000000000000000000000000000000000000000109", - "0x000000000000000000000000000000000000000000000000000000000000010a", - "0x000000000000000000000000000000000000000000000000000000000000010b", - "0x000000000000000000000000000000000000000000000000000000000000010c", - "0x000000000000000000000000000000000000000000000000000000000000010d", - "0x000000000000000000000000000000000000000000000000000000000000010e", - "0x000000000000000000000000000000000000000000000000000000000000010f", - "0x0000000000000000000000000000000000000000000000000000000000000110", - "0x0000000000000000000000000000000000000000000000000000000000000111", - "0x0000000000000000000000000000000000000000000000000000000000000112", - "0x0000000000000000000000000000000000000000000000000000000000000113", - "0x0000000000000000000000000000000000000000000000000000000000000114", - "0x0000000000000000000000000000000000000000000000000000000000000115", - "0x0000000000000000000000000000000000000000000000000000000000000116", - "0x0000000000000000000000000000000000000000000000000000000000000117", - "0x0000000000000000000000000000000000000000000000000000000000000118", - "0x0000000000000000000000000000000000000000000000000000000000000119", - "0x000000000000000000000000000000000000000000000000000000000000011a", - "0x000000000000000000000000000000000000000000000000000000000000011b", - "0x000000000000000000000000000000000000000000000000000000000000011c", - "0x000000000000000000000000000000000000000000000000000000000000011d", - "0x000000000000000000000000000000000000000000000000000000000000011e", - "0x000000000000000000000000000000000000000000000000000000000000011f", - "0x0000000000000000000000000000000000000000000000000000000000000120", - "0x0000000000000000000000000000000000000000000000000000000000000121", - "0x0000000000000000000000000000000000000000000000000000000000000122", - "0x0000000000000000000000000000000000000000000000000000000000000123", - "0x0000000000000000000000000000000000000000000000000000000000000124", - "0x0000000000000000000000000000000000000000000000000000000000000125", - "0x0000000000000000000000000000000000000000000000000000000000000126", - "0x0000000000000000000000000000000000000000000000000000000000000127", - "0x0000000000000000000000000000000000000000000000000000000000000128", - "0x0000000000000000000000000000000000000000000000000000000000000129", - "0x000000000000000000000000000000000000000000000000000000000000012a", - "0x000000000000000000000000000000000000000000000000000000000000012b", - "0x000000000000000000000000000000000000000000000000000000000000012c", - "0x000000000000000000000000000000000000000000000000000000000000012d", - "0x000000000000000000000000000000000000000000000000000000000000012e", - "0x000000000000000000000000000000000000000000000000000000000000012f", - "0x0000000000000000000000000000000000000000000000000000000000000130", - "0x0000000000000000000000000000000000000000000000000000000000000131", - "0x0000000000000000000000000000000000000000000000000000000000000132", - "0x0000000000000000000000000000000000000000000000000000000000000133", - "0x0000000000000000000000000000000000000000000000000000000000000134", - "0x0000000000000000000000000000000000000000000000000000000000000135", - "0x0000000000000000000000000000000000000000000000000000000000000136", - "0x0000000000000000000000000000000000000000000000000000000000000137", - "0x0000000000000000000000000000000000000000000000000000000000000138", - "0x0000000000000000000000000000000000000000000000000000000000000139", - "0x000000000000000000000000000000000000000000000000000000000000013a", - "0x000000000000000000000000000000000000000000000000000000000000013b", - "0x000000000000000000000000000000000000000000000000000000000000013c", - "0x000000000000000000000000000000000000000000000000000000000000013d", - "0x000000000000000000000000000000000000000000000000000000000000013e", - "0x000000000000000000000000000000000000000000000000000000000000013f", - "0x0000000000000000000000000000000000000000000000000000000000000140", - "0x0000000000000000000000000000000000000000000000000000000000000141", - "0x0000000000000000000000000000000000000000000000000000000000000142", - "0x0000000000000000000000000000000000000000000000000000000000000143", - "0x0000000000000000000000000000000000000000000000000000000000000144", - "0x0000000000000000000000000000000000000000000000000000000000000145", - "0x0000000000000000000000000000000000000000000000000000000000000146", - "0x0000000000000000000000000000000000000000000000000000000000000147", - "0x0000000000000000000000000000000000000000000000000000000000000148", - "0x0000000000000000000000000000000000000000000000000000000000000149", - "0x000000000000000000000000000000000000000000000000000000000000014a", - "0x000000000000000000000000000000000000000000000000000000000000014b", - "0x000000000000000000000000000000000000000000000000000000000000014c", - "0x000000000000000000000000000000000000000000000000000000000000014d", - "0x000000000000000000000000000000000000000000000000000000000000014e", - "0x000000000000000000000000000000000000000000000000000000000000014f", - "0x0000000000000000000000000000000000000000000000000000000000000150", - "0x0000000000000000000000000000000000000000000000000000000000000151", - "0x0000000000000000000000000000000000000000000000000000000000000152", - "0x0000000000000000000000000000000000000000000000000000000000000153", - "0x0000000000000000000000000000000000000000000000000000000000000154", - "0x0000000000000000000000000000000000000000000000000000000000000155", - "0x0000000000000000000000000000000000000000000000000000000000000156", - "0x0000000000000000000000000000000000000000000000000000000000000157", - "0x0000000000000000000000000000000000000000000000000000000000000158", - "0x0000000000000000000000000000000000000000000000000000000000000159", - "0x000000000000000000000000000000000000000000000000000000000000015a", - "0x000000000000000000000000000000000000000000000000000000000000015b", - "0x000000000000000000000000000000000000000000000000000000000000015c", - "0x000000000000000000000000000000000000000000000000000000000000015d", - "0x000000000000000000000000000000000000000000000000000000000000015e", - "0x000000000000000000000000000000000000000000000000000000000000015f", - "0x0000000000000000000000000000000000000000000000000000000000000160", - "0x0000000000000000000000000000000000000000000000000000000000000161", - "0x0000000000000000000000000000000000000000000000000000000000000162", - "0x0000000000000000000000000000000000000000000000000000000000000163", - "0x0000000000000000000000000000000000000000000000000000000000000164", - "0x0000000000000000000000000000000000000000000000000000000000000165", - "0x0000000000000000000000000000000000000000000000000000000000000166", - "0x0000000000000000000000000000000000000000000000000000000000000167", - "0x0000000000000000000000000000000000000000000000000000000000000168", - "0x0000000000000000000000000000000000000000000000000000000000000169", - "0x000000000000000000000000000000000000000000000000000000000000016a", - "0x000000000000000000000000000000000000000000000000000000000000016b", - "0x000000000000000000000000000000000000000000000000000000000000016c", - "0x000000000000000000000000000000000000000000000000000000000000016d", - "0x000000000000000000000000000000000000000000000000000000000000016e", - "0x000000000000000000000000000000000000000000000000000000000000016f", - "0x0000000000000000000000000000000000000000000000000000000000000170", - "0x0000000000000000000000000000000000000000000000000000000000000171", - "0x0000000000000000000000000000000000000000000000000000000000000172", - "0x0000000000000000000000000000000000000000000000000000000000000173", - "0x0000000000000000000000000000000000000000000000000000000000000174", - "0x0000000000000000000000000000000000000000000000000000000000000175", - "0x0000000000000000000000000000000000000000000000000000000000000176", - "0x0000000000000000000000000000000000000000000000000000000000000177", - "0x0000000000000000000000000000000000000000000000000000000000000178", - "0x0000000000000000000000000000000000000000000000000000000000000179", - "0x000000000000000000000000000000000000000000000000000000000000017a", - "0x000000000000000000000000000000000000000000000000000000000000017b", - "0x000000000000000000000000000000000000000000000000000000000000017c", - "0x000000000000000000000000000000000000000000000000000000000000017d", - "0x000000000000000000000000000000000000000000000000000000000000017e", - "0x000000000000000000000000000000000000000000000000000000000000017f", - "0x0000000000000000000000000000000000000000000000000000000000000180", - "0x0000000000000000000000000000000000000000000000000000000000000181", - "0x0000000000000000000000000000000000000000000000000000000000000182", - "0x0000000000000000000000000000000000000000000000000000000000000183", - "0x0000000000000000000000000000000000000000000000000000000000000184", - "0x0000000000000000000000000000000000000000000000000000000000000185", - "0x0000000000000000000000000000000000000000000000000000000000000186", - "0x0000000000000000000000000000000000000000000000000000000000000187", - "0x0000000000000000000000000000000000000000000000000000000000000188", - "0x0000000000000000000000000000000000000000000000000000000000000189", - "0x000000000000000000000000000000000000000000000000000000000000018a", - "0x000000000000000000000000000000000000000000000000000000000000018b", - "0x000000000000000000000000000000000000000000000000000000000000018c", - "0x000000000000000000000000000000000000000000000000000000000000018d", - "0x000000000000000000000000000000000000000000000000000000000000018e", - "0x000000000000000000000000000000000000000000000000000000000000018f", - "0x0000000000000000000000000000000000000000000000000000000000000190", - "0x0000000000000000000000000000000000000000000000000000000000000191", - "0x0000000000000000000000000000000000000000000000000000000000000192", - "0x0000000000000000000000000000000000000000000000000000000000000193", - "0x0000000000000000000000000000000000000000000000000000000000000194", - "0x0000000000000000000000000000000000000000000000000000000000000195", - "0x0000000000000000000000000000000000000000000000000000000000000196", - "0x0000000000000000000000000000000000000000000000000000000000000197", - "0x0000000000000000000000000000000000000000000000000000000000000198", - "0x0000000000000000000000000000000000000000000000000000000000000199", - "0x000000000000000000000000000000000000000000000000000000000000019a" -] - - [inputs.parity_root.public_inputs] - sha_root = "0x00de7b349d2306334734e4f58b1302a6ed5a6c796a706f6597a5641b6d468223" - converted_root = "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f" - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" - - [inputs.parity_root.vk_data] - leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000016" - sibling_path = [ - "0x005a4d59d6486e10a3eefab398cca5d3c8e89e178a566d9885c5d7e478e46338", - "0x1fa32700cbe47fec502423d9419340fdfc6b73c146a1b1e42189b4dee5ddb4cc", - "0x07250f720369414b8956bab70d3dbfbe4a5912f128405eedb1c920009dcea92c", - "0x033c4d295fe10d44c10ab7dd6b98731454b30ab8a3b175477338750c07bc4023", - "0x234c347546637311dad66534e5274a6a5db5da51b51baab040dac88807024ce5", - "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" -] - - [inputs.parity_root.vk_data.vk] - key = [ - "0x0000000000000000000000000000000000000000000000000000000000000016", - "0x000000000000000000000000000000000000000000000000000000000000000c", - "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x00000000000000000000000000000051b95d468aa9edbdd7a1e0f23a986c062f", - "0x00000000000000000000000000000000001bad5c453d035ced539f73b9ad9856", - "0x000000000000000000000000000000b9f20b33b45f2cd16ad5d036ab4e3b3e29", - "0x000000000000000000000000000000000024ea357fc8a07811c9d33358737ae6", - "0x000000000000000000000000000000ecd08e9e55edf496bac0902ec569099076", - "0x00000000000000000000000000000000002545be4c6d35893482ac43aecf9ca3", - "0x0000000000000000000000000000007b0429d81df3d0e6f023ad3023885f5d80", - "0x00000000000000000000000000000000001c682d1353fe66ef71491f339cde4c", - "0x00000000000000000000000000000021d27796a33c109672b6cdddafb1014772", - "0x00000000000000000000000000000000002cb8cb3972a4653468363f5cb656aa", - "0x000000000000000000000000000000253a50863b978d9398edeaaadb777a07a1", - "0x00000000000000000000000000000000000ef2db12c6ccbb131452091724f6a1", - "0x0000000000000000000000000000007abf7d869e61f461bad9f630ddf9594b05", - "0x00000000000000000000000000000000001111371317a103bc201e8123d6908b", - "0x00000000000000000000000000000055c64593831da4543a3d4b133e864eaf93", - "0x00000000000000000000000000000000000007aad0d55eaa03d5a23d84a35e60", - "0x000000000000000000000000000000165b401eb09f11cdbf56ba958577c91870", - "0x000000000000000000000000000000000024870f45c37a1866cbe92a8e88bbdd", - "0x00000000000000000000000000000022fabd7922e17d5369ed9c82423af1e455", - "0x000000000000000000000000000000000006649913c8489e9ddf864cbfba7f06", - "0x00000000000000000000000000000069115033b40ed21b2de75356921ceab9bb", - "0x000000000000000000000000000000000017967decbb04dea0b3c47f6cc805ed", - "0x000000000000000000000000000000b28d6694439fbe07553cdd206c5dfedebb", - "0x00000000000000000000000000000000000b08cdac94cf3e333b9195d9397ebe", - "0x000000000000000000000000000000cbe98014674062efea69339e44ebb83efc", - "0x00000000000000000000000000000000001e2260b0e077ac85ce74aaae4e72ef", - "0x000000000000000000000000000000bd27cf39ab646d638453f2fc0af16ba04b", - "0x00000000000000000000000000000000000473943ee569fdf17acac9c955c46f", - "0x000000000000000000000000000000864b31708b62da3d34b9f7ae5931f9696e", - "0x00000000000000000000000000000000000df5131cd2846d3102e898fa953ea0", - "0x000000000000000000000000000000d199787d243d0e9f7198c7f8993b47f431", - "0x0000000000000000000000000000000000161ef18b1311eebfa3ea1e312d40fc", - "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", - "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", - "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", - "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x0000000000000000000000000000006e4a0bfce0ed1188f9db0a6dd0de01ff56", - "0x000000000000000000000000000000000028ffb06695207e8e7beefe7ddd9bf2", - "0x000000000000000000000000000000c3bd4e37af8f5cb75f1e44ee1ac1a27822", - "0x00000000000000000000000000000000001a0419b42f40069bfbfb08563363e5", - "0x0000000000000000000000000000006eed465622852dce8a0702c5327cff0583", - "0x000000000000000000000000000000000022b0941f412859d1cc37a757ca4375", - "0x0000000000000000000000000000008bef872c634b8c03bfe7ff37c00a727192", - "0x000000000000000000000000000000000004906c8767a040a562b166a360c43b", - "0x0000000000000000000000000000002196aef3cb99415b3ac5297aac8f112fc6", - "0x0000000000000000000000000000000000202bc7de55cc5837eb14b1c9170f8b", - "0x000000000000000000000000000000bdf27b518418573439ed9eae4c5e5fb565", - "0x000000000000000000000000000000000017b3d9bbe6a673b931642f99c5da31", - "0x000000000000000000000000000000f02ba591cd0b41bb042d8e128595192f02", - "0x00000000000000000000000000000000000e91c21c980b16cf781f41a63337b6", - "0x000000000000000000000000000000df236435bb93d1ba03853ec32ce9bac516", - "0x00000000000000000000000000000000000c79c6f2ebdbb8e9a9ced4fe147b70", - "0x0000000000000000000000000000003fffb3aa510e7f700cf1014e5872d9c836", - "0x00000000000000000000000000000000002a8a152385a9322608448c3b903a25", - "0x000000000000000000000000000000e0e29574c018f3c6738e2e39d4c5add9a0", - "0x00000000000000000000000000000000000fc61b53a775b4a4abe28883bd4cae", - "0x00000000000000000000000000000015ad8f2e516ea41308c308441bd42c61e8", - "0x00000000000000000000000000000000002ae1b82b97d47244a5cbf6785de890", - "0x000000000000000000000000000000c903532912619760836806241aafc8d682", - "0x00000000000000000000000000000000000ad9c58de8e6372d34bc7aac8d1aca", - "0x0000000000000000000000000000008fa9fb6ea15481186d7cd1fc51794441c9", - "0x000000000000000000000000000000000011ecbb05712b264440c324636f313a", - "0x000000000000000000000000000000f56e21c6f0aaefba2220f3a94f80dab6ce", - "0x00000000000000000000000000000000000a6f225feab651d61030c107381417", - "0x0000000000000000000000000000006367da8ecf84e7656d58a4cf7cc1ef2a74", - "0x00000000000000000000000000000000002856f12f04dfa0785028992bc70c8a", - "0x000000000000000000000000000000540359f38ff410089ec6db690c67f8c0a6", - "0x00000000000000000000000000000000002f7ebc5d4a3f260e4a7008711317cd", - "0x0000000000000000000000000000002b55a45f77effa85ca159aaf39ada36b48", - "0x00000000000000000000000000000000001977d307b0175c7c38a065098ee4f0", - "0x00000000000000000000000000000065d17036201631ee10ae596434d01e5faf", - "0x000000000000000000000000000000000028a0ca170089439ba99c006abb5337", - "0x00000000000000000000000000000061b4a81da9a47d25c6a023ce9989052d14", - "0x000000000000000000000000000000000024f0d3b3ea4a55b1ef68ef0706d74d", - "0x0000000000000000000000000000001e9474df0627017ae3a6588c6675e5d37c", - "0x00000000000000000000000000000000000f9309e016418c2988a76cb9a7e6d0", - "0x0000000000000000000000000000005aabd337c2b20b92b5cd9f68fc113fa8fc", - "0x0000000000000000000000000000000000267e283433e6948f6e830121cf07d6", - "0x000000000000000000000000000000e63c28dcb1403d1abd520e3be26f5ea912", - "0x00000000000000000000000000000000000b8e7e8a4f0ee43c9adb3118d1c77c", - "0x00000000000000000000000000000001cb5edebf7fec67758257f420eb739626", - "0x00000000000000000000000000000000002ac6f62034a546864c00f263827917", - "0x0000000000000000000000000000006ffb02c7e19870982b9368ed26a1a90e5b", - "0x000000000000000000000000000000000021d8e1392945c72edde14af5a71989", - "0x000000000000000000000000000000035fe29e7aa320fcacba3b59ca25bc6419", - "0x000000000000000000000000000000000007f147299102f19d56530c50361528", - "0x000000000000000000000000000000e5be284aab52d0591e1613d5674ab90345", - "0x0000000000000000000000000000000000121e8ab82e001622ed0bacd52bbe03", - "0x00000000000000000000000000000003fa9212b7d0d61e9db75b0d68d8b35153", - "0x00000000000000000000000000000000000fb55f91f49661936a9e62dd35a4ce", - "0x00000000000000000000000000000030c134112f5d817a22a316654112fd7714", - "0x00000000000000000000000000000000000a528aa7ced2566011573552cf302e", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000003b87ae780740d3d14ff8f9a547b2926c1b", - "0x00000000000000000000000000000000001cbcc9a266eec40328a8057d238ebd", - "0x0000000000000000000000000000003f6ec85bee0641c92db9ca4fcc5fa3c24a", - "0x00000000000000000000000000000000002f189078dffab22dd8076b731348c8", - "0x0000000000000000000000000000001fad48d68c46c8ce6bd9b67aa6e588bbe0", - "0x00000000000000000000000000000000002fcda688d3b990ca6451a5841e39c1", - "0x000000000000000000000000000000f44fc69aa2dcf70ea4a66b7a9b23c9ab95", - "0x0000000000000000000000000000000000016f201ae57c6fd54a72dba17e156d", - "0x0000000000000000000000000000007b1d6e61b0d5254c9fba726ae7ae9cc66f", - "0x000000000000000000000000000000000002f7da015e525c659a66da56ae616b", - "0x0000000000000000000000000000004f7b93f9c23397a77423f2d327b024943e", - "0x00000000000000000000000000000000001d4011b86d37adeccdf00f76b47447", - "0x0000000000000000000000000000004a4deb709a4b4c26e852e64bf9f8e3d854", - "0x00000000000000000000000000000000002fdd2702a68fda431a1aae6bb8a36a", - "0x0000000000000000000000000000005bc0bd35cd7f4765aadf5249b6d0a58b74", - "0x00000000000000000000000000000000000d439321d69f2e8851f3a88e18f6cf" -] - hash = "0x269f5cc6356c1bfd4868c38cebcc39f9edcae4cb0f5b72ae04bd23bed6d25ddb" - [inputs.previous_rollup] proof = [ "0x0000000000000000000000000000000000000000000000000000000000000001", @@ -1098,63 +556,63 @@ new_archive_sibling_path = [ [inputs.previous_rollup.public_inputs] num_txs = "0x0000000000000000000000000000000000000000000000000000000000000001" - out_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" - accumulated_fees = "0x00000000000000000000000000000000000000000000000000198e45581dc500" - accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000008992c" + out_hash = "0x006bd7618b0cf7b40e3f107022eee2d411bcc5850fbb774dacc46a15957659c4" + accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" + accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0" [inputs.previous_rollup.public_inputs.constants] - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - protocol_contracts_hash = "0x080e3881bdd4a4e78d52691e5543b50cf820f51baf52af42d7b58c9e15f96ec7" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" + vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.constants.last_archive] - root = "0x1842a814b068f699565f4df77ab9139f1cfab687ef959bf92ba0bb3adf93d8dd" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000009" + root = "0x0fb2945d3438d906d88a216364dbfe9760e96001343468610e01d18182d493d0" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [inputs.previous_rollup.public_inputs.constants.l1_to_l2_tree_snapshot] - root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000001c00" + root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollup.public_inputs.constants.global_variables] - chain_id = "0x0000000000000000000000000000000000000000000000000000000000007a69" - version = "0x000000000000000000000000000000000000000000000000000000005fe47cc3" - block_number = "0x0000000000000000000000000000000000000000000000000000000000000009" - slot_number = "0x0000000000000000000000000000000000000000000000000000000000000044" - timestamp = "0x000000000000000000000000000000000000000000000000000000006a4d22fd" + chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + version = "0x0000000000000000000000000000000000000000000000000000000000000000" + block_number = "0x0000000000000000000000000000000000000000000000000000000000000001" + slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f" + timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186" [inputs.previous_rollup.public_inputs.constants.global_variables.coinbase] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.constants.global_variables.fee_recipient] inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.constants.global_variables.gas_fees] fee_per_da_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" - fee_per_l2_gas = "0x00000000000000000000000000000000000000000000000000000002f8e08bc0" + fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.start_tree_snapshots.note_hash_tree] -root = "0x034b30004686b0cbe57927eaa548af4a428eabee71f4e3e8a581a43084facde5" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000140" +root = "0x2590f2aab19dd791700b4a43d3f52bb88ef2409a3731da8e848663559202e4c6" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.start_tree_snapshots.nullifier_tree] -root = "0x1c13b69ab508e560dc7c25e4f77aed48439749310a58609f31475734efe7287b" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000001c0" +root = "0x18935581a8ed73d08ffd00386fba55ba6c89f3ab848a76b8fedfa9034cee0454" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollup.public_inputs.start_tree_snapshots.public_data_tree] -root = "0x073b8408b98dbac4d5f0c84d47161ee954b8d8e7920e620bf14bc44cb50d07d5" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000008b" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollup.public_inputs.end_tree_snapshots.note_hash_tree] -root = "0x034b30004686b0cbe57927eaa548af4a428eabee71f4e3e8a581a43084facde5" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000180" +root = "0x01612d24a146efc2df9d815a2f733c17486304424577ffb4232fe4cb0c94e1e7" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000040" [inputs.previous_rollup.public_inputs.end_tree_snapshots.nullifier_tree] -root = "0x00260be7577812f167b02eb1c2fa10efc5f169fe19845ada374d4c1518af35f4" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000200" +root = "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" [inputs.previous_rollup.public_inputs.end_tree_snapshots.public_data_tree] -root = "0x2536a3212b711359308d274b8a92fa44465b6ce091dd9369c1331f1ffdeaa8ca" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000008b" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollup.public_inputs.start_sponge_blob] num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -1175,19 +633,19 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 squeeze_mode = false [inputs.previous_rollup.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000080" + num_absorbed_fields = "0x00000000000000000000000000000000000000000000000000000000000004cd" [inputs.previous_rollup.public_inputs.end_sponge_blob.sponge] cache = [ - "0x003c0402012600000305072d0003082d0004092300000baa2d0108062d040609", - "0x00000008020800000902090c0008070a2400000a00000b982600000000000000", - "0x0000220902092d0e020900220902093c0e07082a0100010575fef108377c8a4f" + "0x00000000000000000000000000000000000000000000000000000000b7d1b44d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44c" ] state = [ - "0x0f33f43fb0c44c5e40fdc435630bc7c0216039609097d27d68379cddd3933586", - "0x1cff8078046c1471e788b79130c434cf28c76659cad09a138fefc7715f36b1f9", - "0x176eb17265134a6a87e84f75dbe0a646bc9ad9a317c90773a8c53d59822f4ab5", - "0x1a1440d4df7e4daf64ffa2db4bc1a07844c5992eb81b78c813b4fb385bbf32dc" + "0x152c3ca571fdac98b841ce024a71e95386cf9e12fc75f332e758ec2bbb8abedd", + "0x2b95018fadbe3202af295aba0c2c9bee5fbf974c125ad1df07aac938788075f1", + "0x23f43785270be64381f8aed6a97343880dd65c46edee94cc788f7b233a775aac", + "0x27a409da6f771f48f0170b366f7a66e88ef0416365e20c3d573969923a724b98" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" squeeze_mode = false @@ -1198,10 +656,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x1fc39d0a428c8536dbca551ea79848acf67d89d090fd8c643c7d90f2e8f32340", "0x12ce5a49a1ceca53ada7bee003f929bbd65abaa74e8072a81f304c2c96c44e31", "0x2dd71474f7775d87b6c2986ace5f654686583f0970d7400b1ccf8096dad131b5", - "0x0b5fd0fa25267d5406b05329f1e13e2be58d683fcc8c4ef293934007bf1fedf3", - "0x2a17b9f268be22deec2941ce8de06f485f2d164710a5177d262a4ae86b7c351f", + "0x0aca02f69b05a42958d30ced7da19a9e135e0c83b75e72ae5f7e2bec714a418f", + "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d", "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" + "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd" ] [inputs.previous_rollup.vk_data.vk] @@ -1324,6 +782,1036 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 ] hash = "0x080a62f938a5f53f13c6f7f76c406722d810698e6354fed4f4e52ae528e124f5" + [inputs.message_bundle] + messages = [ + "0x00000000000000000000000000000000000000000000000000000000000005dc", + "0x00000000000000000000000000000000000000000000000000000000000005dd", + "0x00000000000000000000000000000000000000000000000000000000000005de", + "0x00000000000000000000000000000000000000000000000000000000000005df", + "0x00000000000000000000000000000000000000000000000000000000000005e0", + "0x00000000000000000000000000000000000000000000000000000000000005e1", + "0x00000000000000000000000000000000000000000000000000000000000005e2", + "0x00000000000000000000000000000000000000000000000000000000000005e3", + "0x00000000000000000000000000000000000000000000000000000000000005e4", + "0x00000000000000000000000000000000000000000000000000000000000005e5", + "0x00000000000000000000000000000000000000000000000000000000000005e6", + "0x00000000000000000000000000000000000000000000000000000000000005e7", + "0x00000000000000000000000000000000000000000000000000000000000005e8", + "0x00000000000000000000000000000000000000000000000000000000000005e9", + "0x00000000000000000000000000000000000000000000000000000000000005ea", + "0x00000000000000000000000000000000000000000000000000000000000005eb", + "0x00000000000000000000000000000000000000000000000000000000000005ec", + "0x00000000000000000000000000000000000000000000000000000000000005ed", + "0x00000000000000000000000000000000000000000000000000000000000005ee", + "0x00000000000000000000000000000000000000000000000000000000000005ef", + "0x00000000000000000000000000000000000000000000000000000000000005f0", + "0x00000000000000000000000000000000000000000000000000000000000005f1", + "0x00000000000000000000000000000000000000000000000000000000000005f2", + "0x00000000000000000000000000000000000000000000000000000000000005f3", + "0x00000000000000000000000000000000000000000000000000000000000005f4", + "0x00000000000000000000000000000000000000000000000000000000000005f5", + "0x00000000000000000000000000000000000000000000000000000000000005f6", + "0x00000000000000000000000000000000000000000000000000000000000005f7", + "0x00000000000000000000000000000000000000000000000000000000000005f8", + "0x00000000000000000000000000000000000000000000000000000000000005f9", + "0x00000000000000000000000000000000000000000000000000000000000005fa", + "0x00000000000000000000000000000000000000000000000000000000000005fb", + "0x00000000000000000000000000000000000000000000000000000000000005fc", + "0x00000000000000000000000000000000000000000000000000000000000005fd", + "0x00000000000000000000000000000000000000000000000000000000000005fe", + "0x00000000000000000000000000000000000000000000000000000000000005ff", + "0x0000000000000000000000000000000000000000000000000000000000000600", + "0x0000000000000000000000000000000000000000000000000000000000000601", + "0x0000000000000000000000000000000000000000000000000000000000000602", + "0x0000000000000000000000000000000000000000000000000000000000000603", + "0x0000000000000000000000000000000000000000000000000000000000000604", + "0x0000000000000000000000000000000000000000000000000000000000000605", + "0x0000000000000000000000000000000000000000000000000000000000000606", + "0x0000000000000000000000000000000000000000000000000000000000000607", + "0x0000000000000000000000000000000000000000000000000000000000000608", + "0x0000000000000000000000000000000000000000000000000000000000000609", + "0x000000000000000000000000000000000000000000000000000000000000060a", + "0x000000000000000000000000000000000000000000000000000000000000060b", + "0x000000000000000000000000000000000000000000000000000000000000060c", + "0x000000000000000000000000000000000000000000000000000000000000060d", + "0x000000000000000000000000000000000000000000000000000000000000060e", + "0x000000000000000000000000000000000000000000000000000000000000060f", + "0x0000000000000000000000000000000000000000000000000000000000000610", + "0x0000000000000000000000000000000000000000000000000000000000000611", + "0x0000000000000000000000000000000000000000000000000000000000000612", + "0x0000000000000000000000000000000000000000000000000000000000000613", + "0x0000000000000000000000000000000000000000000000000000000000000614", + "0x0000000000000000000000000000000000000000000000000000000000000615", + "0x0000000000000000000000000000000000000000000000000000000000000616", + "0x0000000000000000000000000000000000000000000000000000000000000617", + "0x0000000000000000000000000000000000000000000000000000000000000618", + "0x0000000000000000000000000000000000000000000000000000000000000619", + "0x000000000000000000000000000000000000000000000000000000000000061a", + "0x000000000000000000000000000000000000000000000000000000000000061b", + "0x000000000000000000000000000000000000000000000000000000000000061c", + "0x000000000000000000000000000000000000000000000000000000000000061d", + "0x000000000000000000000000000000000000000000000000000000000000061e", + "0x000000000000000000000000000000000000000000000000000000000000061f", + "0x0000000000000000000000000000000000000000000000000000000000000620", + "0x0000000000000000000000000000000000000000000000000000000000000621", + "0x0000000000000000000000000000000000000000000000000000000000000622", + "0x0000000000000000000000000000000000000000000000000000000000000623", + "0x0000000000000000000000000000000000000000000000000000000000000624", + "0x0000000000000000000000000000000000000000000000000000000000000625", + "0x0000000000000000000000000000000000000000000000000000000000000626", + "0x0000000000000000000000000000000000000000000000000000000000000627", + "0x0000000000000000000000000000000000000000000000000000000000000628", + "0x0000000000000000000000000000000000000000000000000000000000000629", + "0x000000000000000000000000000000000000000000000000000000000000062a", + "0x000000000000000000000000000000000000000000000000000000000000062b", + "0x000000000000000000000000000000000000000000000000000000000000062c", + "0x000000000000000000000000000000000000000000000000000000000000062d", + "0x000000000000000000000000000000000000000000000000000000000000062e", + "0x000000000000000000000000000000000000000000000000000000000000062f", + "0x0000000000000000000000000000000000000000000000000000000000000630", + "0x0000000000000000000000000000000000000000000000000000000000000631", + "0x0000000000000000000000000000000000000000000000000000000000000632", + "0x0000000000000000000000000000000000000000000000000000000000000633", + "0x0000000000000000000000000000000000000000000000000000000000000634", + "0x0000000000000000000000000000000000000000000000000000000000000635", + "0x0000000000000000000000000000000000000000000000000000000000000636", + "0x0000000000000000000000000000000000000000000000000000000000000637", + "0x0000000000000000000000000000000000000000000000000000000000000638", + "0x0000000000000000000000000000000000000000000000000000000000000639", + "0x000000000000000000000000000000000000000000000000000000000000063a", + "0x000000000000000000000000000000000000000000000000000000000000063b", + "0x000000000000000000000000000000000000000000000000000000000000063c", + "0x000000000000000000000000000000000000000000000000000000000000063d", + "0x000000000000000000000000000000000000000000000000000000000000063e", + "0x000000000000000000000000000000000000000000000000000000000000063f", + "0x0000000000000000000000000000000000000000000000000000000000000640", + "0x0000000000000000000000000000000000000000000000000000000000000641", + "0x0000000000000000000000000000000000000000000000000000000000000642", + "0x0000000000000000000000000000000000000000000000000000000000000643", + "0x0000000000000000000000000000000000000000000000000000000000000644", + "0x0000000000000000000000000000000000000000000000000000000000000645", + "0x0000000000000000000000000000000000000000000000000000000000000646", + "0x0000000000000000000000000000000000000000000000000000000000000647", + "0x0000000000000000000000000000000000000000000000000000000000000648", + "0x0000000000000000000000000000000000000000000000000000000000000649", + "0x000000000000000000000000000000000000000000000000000000000000064a", + "0x000000000000000000000000000000000000000000000000000000000000064b", + "0x000000000000000000000000000000000000000000000000000000000000064c", + "0x000000000000000000000000000000000000000000000000000000000000064d", + "0x000000000000000000000000000000000000000000000000000000000000064e", + "0x000000000000000000000000000000000000000000000000000000000000064f", + "0x0000000000000000000000000000000000000000000000000000000000000650", + "0x0000000000000000000000000000000000000000000000000000000000000651", + "0x0000000000000000000000000000000000000000000000000000000000000652", + "0x0000000000000000000000000000000000000000000000000000000000000653", + "0x0000000000000000000000000000000000000000000000000000000000000654", + "0x0000000000000000000000000000000000000000000000000000000000000655", + "0x0000000000000000000000000000000000000000000000000000000000000656", + "0x0000000000000000000000000000000000000000000000000000000000000657", + "0x0000000000000000000000000000000000000000000000000000000000000658", + "0x0000000000000000000000000000000000000000000000000000000000000659", + "0x000000000000000000000000000000000000000000000000000000000000065a", + "0x000000000000000000000000000000000000000000000000000000000000065b", + "0x000000000000000000000000000000000000000000000000000000000000065c", + "0x000000000000000000000000000000000000000000000000000000000000065d", + "0x000000000000000000000000000000000000000000000000000000000000065e", + "0x000000000000000000000000000000000000000000000000000000000000065f", + "0x0000000000000000000000000000000000000000000000000000000000000660", + "0x0000000000000000000000000000000000000000000000000000000000000661", + "0x0000000000000000000000000000000000000000000000000000000000000662", + "0x0000000000000000000000000000000000000000000000000000000000000663", + "0x0000000000000000000000000000000000000000000000000000000000000664", + "0x0000000000000000000000000000000000000000000000000000000000000665", + "0x0000000000000000000000000000000000000000000000000000000000000666", + "0x0000000000000000000000000000000000000000000000000000000000000667", + "0x0000000000000000000000000000000000000000000000000000000000000668", + "0x0000000000000000000000000000000000000000000000000000000000000669", + "0x000000000000000000000000000000000000000000000000000000000000066a", + "0x000000000000000000000000000000000000000000000000000000000000066b", + "0x000000000000000000000000000000000000000000000000000000000000066c", + "0x000000000000000000000000000000000000000000000000000000000000066d", + "0x000000000000000000000000000000000000000000000000000000000000066e", + "0x000000000000000000000000000000000000000000000000000000000000066f", + "0x0000000000000000000000000000000000000000000000000000000000000670", + "0x0000000000000000000000000000000000000000000000000000000000000671", + "0x0000000000000000000000000000000000000000000000000000000000000672", + "0x0000000000000000000000000000000000000000000000000000000000000673", + "0x0000000000000000000000000000000000000000000000000000000000000674", + "0x0000000000000000000000000000000000000000000000000000000000000675", + "0x0000000000000000000000000000000000000000000000000000000000000676", + "0x0000000000000000000000000000000000000000000000000000000000000677", + "0x0000000000000000000000000000000000000000000000000000000000000678", + "0x0000000000000000000000000000000000000000000000000000000000000679", + "0x000000000000000000000000000000000000000000000000000000000000067a", + "0x000000000000000000000000000000000000000000000000000000000000067b", + "0x000000000000000000000000000000000000000000000000000000000000067c", + "0x000000000000000000000000000000000000000000000000000000000000067d", + "0x000000000000000000000000000000000000000000000000000000000000067e", + "0x000000000000000000000000000000000000000000000000000000000000067f", + "0x0000000000000000000000000000000000000000000000000000000000000680", + "0x0000000000000000000000000000000000000000000000000000000000000681", + "0x0000000000000000000000000000000000000000000000000000000000000682", + "0x0000000000000000000000000000000000000000000000000000000000000683", + "0x0000000000000000000000000000000000000000000000000000000000000684", + "0x0000000000000000000000000000000000000000000000000000000000000685", + "0x0000000000000000000000000000000000000000000000000000000000000686", + "0x0000000000000000000000000000000000000000000000000000000000000687", + "0x0000000000000000000000000000000000000000000000000000000000000688", + "0x0000000000000000000000000000000000000000000000000000000000000689", + "0x000000000000000000000000000000000000000000000000000000000000068a", + "0x000000000000000000000000000000000000000000000000000000000000068b", + "0x000000000000000000000000000000000000000000000000000000000000068c", + "0x000000000000000000000000000000000000000000000000000000000000068d", + "0x000000000000000000000000000000000000000000000000000000000000068e", + "0x000000000000000000000000000000000000000000000000000000000000068f", + "0x0000000000000000000000000000000000000000000000000000000000000690", + "0x0000000000000000000000000000000000000000000000000000000000000691", + "0x0000000000000000000000000000000000000000000000000000000000000692", + "0x0000000000000000000000000000000000000000000000000000000000000693", + "0x0000000000000000000000000000000000000000000000000000000000000694", + "0x0000000000000000000000000000000000000000000000000000000000000695", + "0x0000000000000000000000000000000000000000000000000000000000000696", + "0x0000000000000000000000000000000000000000000000000000000000000697", + "0x0000000000000000000000000000000000000000000000000000000000000698", + "0x0000000000000000000000000000000000000000000000000000000000000699", + "0x000000000000000000000000000000000000000000000000000000000000069a", + "0x000000000000000000000000000000000000000000000000000000000000069b", + "0x000000000000000000000000000000000000000000000000000000000000069c", + "0x000000000000000000000000000000000000000000000000000000000000069d", + "0x000000000000000000000000000000000000000000000000000000000000069e", + "0x000000000000000000000000000000000000000000000000000000000000069f", + "0x00000000000000000000000000000000000000000000000000000000000006a0", + "0x00000000000000000000000000000000000000000000000000000000000006a1", + "0x00000000000000000000000000000000000000000000000000000000000006a2", + "0x00000000000000000000000000000000000000000000000000000000000006a3", + "0x00000000000000000000000000000000000000000000000000000000000006a4", + "0x00000000000000000000000000000000000000000000000000000000000006a5", + "0x00000000000000000000000000000000000000000000000000000000000006a6", + "0x00000000000000000000000000000000000000000000000000000000000006a7", + "0x00000000000000000000000000000000000000000000000000000000000006a8", + "0x00000000000000000000000000000000000000000000000000000000000006a9", + "0x00000000000000000000000000000000000000000000000000000000000006aa", + "0x00000000000000000000000000000000000000000000000000000000000006ab", + "0x00000000000000000000000000000000000000000000000000000000000006ac", + "0x00000000000000000000000000000000000000000000000000000000000006ad", + "0x00000000000000000000000000000000000000000000000000000000000006ae", + "0x00000000000000000000000000000000000000000000000000000000000006af", + "0x00000000000000000000000000000000000000000000000000000000000006b0", + "0x00000000000000000000000000000000000000000000000000000000000006b1", + "0x00000000000000000000000000000000000000000000000000000000000006b2", + "0x00000000000000000000000000000000000000000000000000000000000006b3", + "0x00000000000000000000000000000000000000000000000000000000000006b4", + "0x00000000000000000000000000000000000000000000000000000000000006b5", + "0x00000000000000000000000000000000000000000000000000000000000006b6", + "0x00000000000000000000000000000000000000000000000000000000000006b7", + "0x00000000000000000000000000000000000000000000000000000000000006b8", + "0x00000000000000000000000000000000000000000000000000000000000006b9", + "0x00000000000000000000000000000000000000000000000000000000000006ba", + "0x00000000000000000000000000000000000000000000000000000000000006bb", + "0x00000000000000000000000000000000000000000000000000000000000006bc", + "0x00000000000000000000000000000000000000000000000000000000000006bd", + "0x00000000000000000000000000000000000000000000000000000000000006be", + "0x00000000000000000000000000000000000000000000000000000000000006bf", + "0x00000000000000000000000000000000000000000000000000000000000006c0", + "0x00000000000000000000000000000000000000000000000000000000000006c1", + "0x00000000000000000000000000000000000000000000000000000000000006c2", + "0x00000000000000000000000000000000000000000000000000000000000006c3", + "0x00000000000000000000000000000000000000000000000000000000000006c4", + "0x00000000000000000000000000000000000000000000000000000000000006c5", + "0x00000000000000000000000000000000000000000000000000000000000006c6", + "0x00000000000000000000000000000000000000000000000000000000000006c7", + "0x00000000000000000000000000000000000000000000000000000000000006c8", + "0x00000000000000000000000000000000000000000000000000000000000006c9", + "0x00000000000000000000000000000000000000000000000000000000000006ca", + "0x00000000000000000000000000000000000000000000000000000000000006cb", + "0x00000000000000000000000000000000000000000000000000000000000006cc", + "0x00000000000000000000000000000000000000000000000000000000000006cd", + "0x00000000000000000000000000000000000000000000000000000000000006ce", + "0x00000000000000000000000000000000000000000000000000000000000006cf", + "0x00000000000000000000000000000000000000000000000000000000000006d0", + "0x00000000000000000000000000000000000000000000000000000000000006d1", + "0x00000000000000000000000000000000000000000000000000000000000006d2", + "0x00000000000000000000000000000000000000000000000000000000000006d3", + "0x00000000000000000000000000000000000000000000000000000000000006d4", + "0x00000000000000000000000000000000000000000000000000000000000006d5", + "0x00000000000000000000000000000000000000000000000000000000000006d6", + "0x00000000000000000000000000000000000000000000000000000000000006d7", + "0x00000000000000000000000000000000000000000000000000000000000006d8", + "0x00000000000000000000000000000000000000000000000000000000000006d9", + "0x00000000000000000000000000000000000000000000000000000000000006da", + "0x00000000000000000000000000000000000000000000000000000000000006db", + "0x00000000000000000000000000000000000000000000000000000000000006dc", + "0x00000000000000000000000000000000000000000000000000000000000006dd", + "0x00000000000000000000000000000000000000000000000000000000000006de", + "0x00000000000000000000000000000000000000000000000000000000000006df", + "0x00000000000000000000000000000000000000000000000000000000000006e0", + "0x00000000000000000000000000000000000000000000000000000000000006e1", + "0x00000000000000000000000000000000000000000000000000000000000006e2", + "0x00000000000000000000000000000000000000000000000000000000000006e3", + "0x00000000000000000000000000000000000000000000000000000000000006e4", + "0x00000000000000000000000000000000000000000000000000000000000006e5", + "0x00000000000000000000000000000000000000000000000000000000000006e6", + "0x00000000000000000000000000000000000000000000000000000000000006e7", + "0x00000000000000000000000000000000000000000000000000000000000006e8", + "0x00000000000000000000000000000000000000000000000000000000000006e9", + "0x00000000000000000000000000000000000000000000000000000000000006ea", + "0x00000000000000000000000000000000000000000000000000000000000006eb", + "0x00000000000000000000000000000000000000000000000000000000000006ec", + "0x00000000000000000000000000000000000000000000000000000000000006ed", + "0x00000000000000000000000000000000000000000000000000000000000006ee", + "0x00000000000000000000000000000000000000000000000000000000000006ef", + "0x00000000000000000000000000000000000000000000000000000000000006f0", + "0x00000000000000000000000000000000000000000000000000000000000006f1", + "0x00000000000000000000000000000000000000000000000000000000000006f2", + "0x00000000000000000000000000000000000000000000000000000000000006f3", + "0x00000000000000000000000000000000000000000000000000000000000006f4", + "0x00000000000000000000000000000000000000000000000000000000000006f5", + "0x00000000000000000000000000000000000000000000000000000000000006f6", + "0x00000000000000000000000000000000000000000000000000000000000006f7", + "0x00000000000000000000000000000000000000000000000000000000000006f8", + "0x00000000000000000000000000000000000000000000000000000000000006f9", + "0x00000000000000000000000000000000000000000000000000000000000006fa", + "0x00000000000000000000000000000000000000000000000000000000000006fb", + "0x00000000000000000000000000000000000000000000000000000000000006fc", + "0x00000000000000000000000000000000000000000000000000000000000006fd", + "0x00000000000000000000000000000000000000000000000000000000000006fe", + "0x00000000000000000000000000000000000000000000000000000000000006ff", + "0x0000000000000000000000000000000000000000000000000000000000000700", + "0x0000000000000000000000000000000000000000000000000000000000000701", + "0x0000000000000000000000000000000000000000000000000000000000000702", + "0x0000000000000000000000000000000000000000000000000000000000000703", + "0x0000000000000000000000000000000000000000000000000000000000000704", + "0x0000000000000000000000000000000000000000000000000000000000000705", + "0x0000000000000000000000000000000000000000000000000000000000000706", + "0x0000000000000000000000000000000000000000000000000000000000000707", + "0x0000000000000000000000000000000000000000000000000000000000000708", + "0x0000000000000000000000000000000000000000000000000000000000000709", + "0x000000000000000000000000000000000000000000000000000000000000070a", + "0x000000000000000000000000000000000000000000000000000000000000070b", + "0x000000000000000000000000000000000000000000000000000000000000070c", + "0x000000000000000000000000000000000000000000000000000000000000070d", + "0x000000000000000000000000000000000000000000000000000000000000070e", + "0x000000000000000000000000000000000000000000000000000000000000070f", + "0x0000000000000000000000000000000000000000000000000000000000000710", + "0x0000000000000000000000000000000000000000000000000000000000000711", + "0x0000000000000000000000000000000000000000000000000000000000000712", + "0x0000000000000000000000000000000000000000000000000000000000000713", + "0x0000000000000000000000000000000000000000000000000000000000000714", + "0x0000000000000000000000000000000000000000000000000000000000000715", + "0x0000000000000000000000000000000000000000000000000000000000000716", + "0x0000000000000000000000000000000000000000000000000000000000000717", + "0x0000000000000000000000000000000000000000000000000000000000000718", + "0x0000000000000000000000000000000000000000000000000000000000000719", + "0x000000000000000000000000000000000000000000000000000000000000071a", + "0x000000000000000000000000000000000000000000000000000000000000071b", + "0x000000000000000000000000000000000000000000000000000000000000071c", + "0x000000000000000000000000000000000000000000000000000000000000071d", + "0x000000000000000000000000000000000000000000000000000000000000071e", + "0x000000000000000000000000000000000000000000000000000000000000071f", + "0x0000000000000000000000000000000000000000000000000000000000000720", + "0x0000000000000000000000000000000000000000000000000000000000000721", + "0x0000000000000000000000000000000000000000000000000000000000000722", + "0x0000000000000000000000000000000000000000000000000000000000000723", + "0x0000000000000000000000000000000000000000000000000000000000000724", + "0x0000000000000000000000000000000000000000000000000000000000000725", + "0x0000000000000000000000000000000000000000000000000000000000000726", + "0x0000000000000000000000000000000000000000000000000000000000000727", + "0x0000000000000000000000000000000000000000000000000000000000000728", + "0x0000000000000000000000000000000000000000000000000000000000000729", + "0x000000000000000000000000000000000000000000000000000000000000072a", + "0x000000000000000000000000000000000000000000000000000000000000072b", + "0x000000000000000000000000000000000000000000000000000000000000072c", + "0x000000000000000000000000000000000000000000000000000000000000072d", + "0x000000000000000000000000000000000000000000000000000000000000072e", + "0x000000000000000000000000000000000000000000000000000000000000072f", + "0x0000000000000000000000000000000000000000000000000000000000000730", + "0x0000000000000000000000000000000000000000000000000000000000000731", + "0x0000000000000000000000000000000000000000000000000000000000000732", + "0x0000000000000000000000000000000000000000000000000000000000000733", + "0x0000000000000000000000000000000000000000000000000000000000000734", + "0x0000000000000000000000000000000000000000000000000000000000000735", + "0x0000000000000000000000000000000000000000000000000000000000000736", + "0x0000000000000000000000000000000000000000000000000000000000000737", + "0x0000000000000000000000000000000000000000000000000000000000000738", + "0x0000000000000000000000000000000000000000000000000000000000000739", + "0x000000000000000000000000000000000000000000000000000000000000073a", + "0x000000000000000000000000000000000000000000000000000000000000073b", + "0x000000000000000000000000000000000000000000000000000000000000073c", + "0x000000000000000000000000000000000000000000000000000000000000073d", + "0x000000000000000000000000000000000000000000000000000000000000073e", + "0x000000000000000000000000000000000000000000000000000000000000073f", + "0x0000000000000000000000000000000000000000000000000000000000000740", + "0x0000000000000000000000000000000000000000000000000000000000000741", + "0x0000000000000000000000000000000000000000000000000000000000000742", + "0x0000000000000000000000000000000000000000000000000000000000000743", + "0x0000000000000000000000000000000000000000000000000000000000000744", + "0x0000000000000000000000000000000000000000000000000000000000000745", + "0x0000000000000000000000000000000000000000000000000000000000000746", + "0x0000000000000000000000000000000000000000000000000000000000000747", + "0x0000000000000000000000000000000000000000000000000000000000000748", + "0x0000000000000000000000000000000000000000000000000000000000000749", + "0x000000000000000000000000000000000000000000000000000000000000074a", + "0x000000000000000000000000000000000000000000000000000000000000074b", + "0x000000000000000000000000000000000000000000000000000000000000074c", + "0x000000000000000000000000000000000000000000000000000000000000074d", + "0x000000000000000000000000000000000000000000000000000000000000074e", + "0x000000000000000000000000000000000000000000000000000000000000074f", + "0x0000000000000000000000000000000000000000000000000000000000000750", + "0x0000000000000000000000000000000000000000000000000000000000000751", + "0x0000000000000000000000000000000000000000000000000000000000000752", + "0x0000000000000000000000000000000000000000000000000000000000000753", + "0x0000000000000000000000000000000000000000000000000000000000000754", + "0x0000000000000000000000000000000000000000000000000000000000000755", + "0x0000000000000000000000000000000000000000000000000000000000000756", + "0x0000000000000000000000000000000000000000000000000000000000000757", + "0x0000000000000000000000000000000000000000000000000000000000000758", + "0x0000000000000000000000000000000000000000000000000000000000000759", + "0x000000000000000000000000000000000000000000000000000000000000075a", + "0x000000000000000000000000000000000000000000000000000000000000075b", + "0x000000000000000000000000000000000000000000000000000000000000075c", + "0x000000000000000000000000000000000000000000000000000000000000075d", + "0x000000000000000000000000000000000000000000000000000000000000075e", + "0x000000000000000000000000000000000000000000000000000000000000075f", + "0x0000000000000000000000000000000000000000000000000000000000000760", + "0x0000000000000000000000000000000000000000000000000000000000000761", + "0x0000000000000000000000000000000000000000000000000000000000000762", + "0x0000000000000000000000000000000000000000000000000000000000000763", + "0x0000000000000000000000000000000000000000000000000000000000000764", + "0x0000000000000000000000000000000000000000000000000000000000000765", + "0x0000000000000000000000000000000000000000000000000000000000000766", + "0x0000000000000000000000000000000000000000000000000000000000000767", + "0x0000000000000000000000000000000000000000000000000000000000000768", + "0x0000000000000000000000000000000000000000000000000000000000000769", + "0x000000000000000000000000000000000000000000000000000000000000076a", + "0x000000000000000000000000000000000000000000000000000000000000076b", + "0x000000000000000000000000000000000000000000000000000000000000076c", + "0x000000000000000000000000000000000000000000000000000000000000076d", + "0x000000000000000000000000000000000000000000000000000000000000076e", + "0x000000000000000000000000000000000000000000000000000000000000076f", + "0x0000000000000000000000000000000000000000000000000000000000000770", + "0x0000000000000000000000000000000000000000000000000000000000000771", + "0x0000000000000000000000000000000000000000000000000000000000000772", + "0x0000000000000000000000000000000000000000000000000000000000000773", + "0x0000000000000000000000000000000000000000000000000000000000000774", + "0x0000000000000000000000000000000000000000000000000000000000000775", + "0x0000000000000000000000000000000000000000000000000000000000000776", + "0x0000000000000000000000000000000000000000000000000000000000000777", + "0x0000000000000000000000000000000000000000000000000000000000000778", + "0x0000000000000000000000000000000000000000000000000000000000000779", + "0x000000000000000000000000000000000000000000000000000000000000077a", + "0x000000000000000000000000000000000000000000000000000000000000077b", + "0x000000000000000000000000000000000000000000000000000000000000077c", + "0x000000000000000000000000000000000000000000000000000000000000077d", + "0x000000000000000000000000000000000000000000000000000000000000077e", + "0x000000000000000000000000000000000000000000000000000000000000077f", + "0x0000000000000000000000000000000000000000000000000000000000000780", + "0x0000000000000000000000000000000000000000000000000000000000000781", + "0x0000000000000000000000000000000000000000000000000000000000000782", + "0x0000000000000000000000000000000000000000000000000000000000000783", + "0x0000000000000000000000000000000000000000000000000000000000000784", + "0x0000000000000000000000000000000000000000000000000000000000000785", + "0x0000000000000000000000000000000000000000000000000000000000000786", + "0x0000000000000000000000000000000000000000000000000000000000000787", + "0x0000000000000000000000000000000000000000000000000000000000000788", + "0x0000000000000000000000000000000000000000000000000000000000000789", + "0x000000000000000000000000000000000000000000000000000000000000078a", + "0x000000000000000000000000000000000000000000000000000000000000078b", + "0x000000000000000000000000000000000000000000000000000000000000078c", + "0x000000000000000000000000000000000000000000000000000000000000078d", + "0x000000000000000000000000000000000000000000000000000000000000078e", + "0x000000000000000000000000000000000000000000000000000000000000078f", + "0x0000000000000000000000000000000000000000000000000000000000000790", + "0x0000000000000000000000000000000000000000000000000000000000000791", + "0x0000000000000000000000000000000000000000000000000000000000000792", + "0x0000000000000000000000000000000000000000000000000000000000000793", + "0x0000000000000000000000000000000000000000000000000000000000000794", + "0x0000000000000000000000000000000000000000000000000000000000000795", + "0x0000000000000000000000000000000000000000000000000000000000000796", + "0x0000000000000000000000000000000000000000000000000000000000000797", + "0x0000000000000000000000000000000000000000000000000000000000000798", + "0x0000000000000000000000000000000000000000000000000000000000000799", + "0x000000000000000000000000000000000000000000000000000000000000079a", + "0x000000000000000000000000000000000000000000000000000000000000079b", + "0x000000000000000000000000000000000000000000000000000000000000079c", + "0x000000000000000000000000000000000000000000000000000000000000079d", + "0x000000000000000000000000000000000000000000000000000000000000079e", + "0x000000000000000000000000000000000000000000000000000000000000079f", + "0x00000000000000000000000000000000000000000000000000000000000007a0", + "0x00000000000000000000000000000000000000000000000000000000000007a1", + "0x00000000000000000000000000000000000000000000000000000000000007a2", + "0x00000000000000000000000000000000000000000000000000000000000007a3", + "0x00000000000000000000000000000000000000000000000000000000000007a4", + "0x00000000000000000000000000000000000000000000000000000000000007a5", + "0x00000000000000000000000000000000000000000000000000000000000007a6", + "0x00000000000000000000000000000000000000000000000000000000000007a7", + "0x00000000000000000000000000000000000000000000000000000000000007a8", + "0x00000000000000000000000000000000000000000000000000000000000007a9", + "0x00000000000000000000000000000000000000000000000000000000000007aa", + "0x00000000000000000000000000000000000000000000000000000000000007ab", + "0x00000000000000000000000000000000000000000000000000000000000007ac", + "0x00000000000000000000000000000000000000000000000000000000000007ad", + "0x00000000000000000000000000000000000000000000000000000000000007ae", + "0x00000000000000000000000000000000000000000000000000000000000007af", + "0x00000000000000000000000000000000000000000000000000000000000007b0", + "0x00000000000000000000000000000000000000000000000000000000000007b1", + "0x00000000000000000000000000000000000000000000000000000000000007b2", + "0x00000000000000000000000000000000000000000000000000000000000007b3", + "0x00000000000000000000000000000000000000000000000000000000000007b4", + "0x00000000000000000000000000000000000000000000000000000000000007b5", + "0x00000000000000000000000000000000000000000000000000000000000007b6", + "0x00000000000000000000000000000000000000000000000000000000000007b7", + "0x00000000000000000000000000000000000000000000000000000000000007b8", + "0x00000000000000000000000000000000000000000000000000000000000007b9", + "0x00000000000000000000000000000000000000000000000000000000000007ba", + "0x00000000000000000000000000000000000000000000000000000000000007bb", + "0x00000000000000000000000000000000000000000000000000000000000007bc", + "0x00000000000000000000000000000000000000000000000000000000000007bd", + "0x00000000000000000000000000000000000000000000000000000000000007be", + "0x00000000000000000000000000000000000000000000000000000000000007bf", + "0x00000000000000000000000000000000000000000000000000000000000007c0", + "0x00000000000000000000000000000000000000000000000000000000000007c1", + "0x00000000000000000000000000000000000000000000000000000000000007c2", + "0x00000000000000000000000000000000000000000000000000000000000007c3", + "0x00000000000000000000000000000000000000000000000000000000000007c4", + "0x00000000000000000000000000000000000000000000000000000000000007c5", + "0x00000000000000000000000000000000000000000000000000000000000007c6", + "0x00000000000000000000000000000000000000000000000000000000000007c7", + "0x00000000000000000000000000000000000000000000000000000000000007c8", + "0x00000000000000000000000000000000000000000000000000000000000007c9", + "0x00000000000000000000000000000000000000000000000000000000000007ca", + "0x00000000000000000000000000000000000000000000000000000000000007cb", + "0x00000000000000000000000000000000000000000000000000000000000007cc", + "0x00000000000000000000000000000000000000000000000000000000000007cd", + "0x00000000000000000000000000000000000000000000000000000000000007ce", + "0x00000000000000000000000000000000000000000000000000000000000007cf", + "0x00000000000000000000000000000000000000000000000000000000000007d0", + "0x00000000000000000000000000000000000000000000000000000000000007d1", + "0x00000000000000000000000000000000000000000000000000000000000007d2", + "0x00000000000000000000000000000000000000000000000000000000000007d3", + "0x00000000000000000000000000000000000000000000000000000000000007d4", + "0x00000000000000000000000000000000000000000000000000000000000007d5", + "0x00000000000000000000000000000000000000000000000000000000000007d6", + "0x00000000000000000000000000000000000000000000000000000000000007d7", + "0x00000000000000000000000000000000000000000000000000000000000007d8", + "0x00000000000000000000000000000000000000000000000000000000000007d9", + "0x00000000000000000000000000000000000000000000000000000000000007da", + "0x00000000000000000000000000000000000000000000000000000000000007db", + "0x00000000000000000000000000000000000000000000000000000000000007dc", + "0x00000000000000000000000000000000000000000000000000000000000007dd", + "0x00000000000000000000000000000000000000000000000000000000000007de", + "0x00000000000000000000000000000000000000000000000000000000000007df", + "0x00000000000000000000000000000000000000000000000000000000000007e0", + "0x00000000000000000000000000000000000000000000000000000000000007e1", + "0x00000000000000000000000000000000000000000000000000000000000007e2", + "0x00000000000000000000000000000000000000000000000000000000000007e3", + "0x00000000000000000000000000000000000000000000000000000000000007e4", + "0x00000000000000000000000000000000000000000000000000000000000007e5", + "0x00000000000000000000000000000000000000000000000000000000000007e6", + "0x00000000000000000000000000000000000000000000000000000000000007e7", + "0x00000000000000000000000000000000000000000000000000000000000007e8", + "0x00000000000000000000000000000000000000000000000000000000000007e9", + "0x00000000000000000000000000000000000000000000000000000000000007ea", + "0x00000000000000000000000000000000000000000000000000000000000007eb", + "0x00000000000000000000000000000000000000000000000000000000000007ec", + "0x00000000000000000000000000000000000000000000000000000000000007ed", + "0x00000000000000000000000000000000000000000000000000000000000007ee", + "0x00000000000000000000000000000000000000000000000000000000000007ef", + "0x00000000000000000000000000000000000000000000000000000000000007f0", + "0x00000000000000000000000000000000000000000000000000000000000007f1", + "0x00000000000000000000000000000000000000000000000000000000000007f2", + "0x00000000000000000000000000000000000000000000000000000000000007f3", + "0x00000000000000000000000000000000000000000000000000000000000007f4", + "0x00000000000000000000000000000000000000000000000000000000000007f5", + "0x00000000000000000000000000000000000000000000000000000000000007f6", + "0x00000000000000000000000000000000000000000000000000000000000007f7", + "0x00000000000000000000000000000000000000000000000000000000000007f8", + "0x00000000000000000000000000000000000000000000000000000000000007f9", + "0x00000000000000000000000000000000000000000000000000000000000007fa", + "0x00000000000000000000000000000000000000000000000000000000000007fb", + "0x00000000000000000000000000000000000000000000000000000000000007fc", + "0x00000000000000000000000000000000000000000000000000000000000007fd", + "0x00000000000000000000000000000000000000000000000000000000000007fe", + "0x00000000000000000000000000000000000000000000000000000000000007ff", + "0x0000000000000000000000000000000000000000000000000000000000000800", + "0x0000000000000000000000000000000000000000000000000000000000000801", + "0x0000000000000000000000000000000000000000000000000000000000000802", + "0x0000000000000000000000000000000000000000000000000000000000000803", + "0x0000000000000000000000000000000000000000000000000000000000000804", + "0x0000000000000000000000000000000000000000000000000000000000000805", + "0x0000000000000000000000000000000000000000000000000000000000000806", + "0x0000000000000000000000000000000000000000000000000000000000000807", + "0x0000000000000000000000000000000000000000000000000000000000000808", + "0x0000000000000000000000000000000000000000000000000000000000000809", + "0x000000000000000000000000000000000000000000000000000000000000080a", + "0x000000000000000000000000000000000000000000000000000000000000080b", + "0x000000000000000000000000000000000000000000000000000000000000080c", + "0x000000000000000000000000000000000000000000000000000000000000080d", + "0x000000000000000000000000000000000000000000000000000000000000080e", + "0x000000000000000000000000000000000000000000000000000000000000080f", + "0x0000000000000000000000000000000000000000000000000000000000000810", + "0x0000000000000000000000000000000000000000000000000000000000000811", + "0x0000000000000000000000000000000000000000000000000000000000000812", + "0x0000000000000000000000000000000000000000000000000000000000000813", + "0x0000000000000000000000000000000000000000000000000000000000000814", + "0x0000000000000000000000000000000000000000000000000000000000000815", + "0x0000000000000000000000000000000000000000000000000000000000000816", + "0x0000000000000000000000000000000000000000000000000000000000000817", + "0x0000000000000000000000000000000000000000000000000000000000000818", + "0x0000000000000000000000000000000000000000000000000000000000000819", + "0x000000000000000000000000000000000000000000000000000000000000081a", + "0x000000000000000000000000000000000000000000000000000000000000081b", + "0x000000000000000000000000000000000000000000000000000000000000081c", + "0x000000000000000000000000000000000000000000000000000000000000081d", + "0x000000000000000000000000000000000000000000000000000000000000081e", + "0x000000000000000000000000000000000000000000000000000000000000081f", + "0x0000000000000000000000000000000000000000000000000000000000000820", + "0x0000000000000000000000000000000000000000000000000000000000000821", + "0x0000000000000000000000000000000000000000000000000000000000000822", + "0x0000000000000000000000000000000000000000000000000000000000000823", + "0x0000000000000000000000000000000000000000000000000000000000000824", + "0x0000000000000000000000000000000000000000000000000000000000000825", + "0x0000000000000000000000000000000000000000000000000000000000000826", + "0x0000000000000000000000000000000000000000000000000000000000000827", + "0x0000000000000000000000000000000000000000000000000000000000000828", + "0x0000000000000000000000000000000000000000000000000000000000000829", + "0x000000000000000000000000000000000000000000000000000000000000082a", + "0x000000000000000000000000000000000000000000000000000000000000082b", + "0x000000000000000000000000000000000000000000000000000000000000082c", + "0x000000000000000000000000000000000000000000000000000000000000082d", + "0x000000000000000000000000000000000000000000000000000000000000082e", + "0x000000000000000000000000000000000000000000000000000000000000082f", + "0x0000000000000000000000000000000000000000000000000000000000000830", + "0x0000000000000000000000000000000000000000000000000000000000000831", + "0x0000000000000000000000000000000000000000000000000000000000000832", + "0x0000000000000000000000000000000000000000000000000000000000000833", + "0x0000000000000000000000000000000000000000000000000000000000000834", + "0x0000000000000000000000000000000000000000000000000000000000000835", + "0x0000000000000000000000000000000000000000000000000000000000000836", + "0x0000000000000000000000000000000000000000000000000000000000000837", + "0x0000000000000000000000000000000000000000000000000000000000000838", + "0x0000000000000000000000000000000000000000000000000000000000000839", + "0x000000000000000000000000000000000000000000000000000000000000083a", + "0x000000000000000000000000000000000000000000000000000000000000083b", + "0x000000000000000000000000000000000000000000000000000000000000083c", + "0x000000000000000000000000000000000000000000000000000000000000083d", + "0x000000000000000000000000000000000000000000000000000000000000083e", + "0x000000000000000000000000000000000000000000000000000000000000083f", + "0x0000000000000000000000000000000000000000000000000000000000000840", + "0x0000000000000000000000000000000000000000000000000000000000000841", + "0x0000000000000000000000000000000000000000000000000000000000000842", + "0x0000000000000000000000000000000000000000000000000000000000000843", + "0x0000000000000000000000000000000000000000000000000000000000000844", + "0x0000000000000000000000000000000000000000000000000000000000000845", + "0x0000000000000000000000000000000000000000000000000000000000000846", + "0x0000000000000000000000000000000000000000000000000000000000000847", + "0x0000000000000000000000000000000000000000000000000000000000000848", + "0x0000000000000000000000000000000000000000000000000000000000000849", + "0x000000000000000000000000000000000000000000000000000000000000084a", + "0x000000000000000000000000000000000000000000000000000000000000084b", + "0x000000000000000000000000000000000000000000000000000000000000084c", + "0x000000000000000000000000000000000000000000000000000000000000084d", + "0x000000000000000000000000000000000000000000000000000000000000084e", + "0x000000000000000000000000000000000000000000000000000000000000084f", + "0x0000000000000000000000000000000000000000000000000000000000000850", + "0x0000000000000000000000000000000000000000000000000000000000000851", + "0x0000000000000000000000000000000000000000000000000000000000000852", + "0x0000000000000000000000000000000000000000000000000000000000000853", + "0x0000000000000000000000000000000000000000000000000000000000000854", + "0x0000000000000000000000000000000000000000000000000000000000000855", + "0x0000000000000000000000000000000000000000000000000000000000000856", + "0x0000000000000000000000000000000000000000000000000000000000000857", + "0x0000000000000000000000000000000000000000000000000000000000000858", + "0x0000000000000000000000000000000000000000000000000000000000000859", + "0x000000000000000000000000000000000000000000000000000000000000085a", + "0x000000000000000000000000000000000000000000000000000000000000085b", + "0x000000000000000000000000000000000000000000000000000000000000085c", + "0x000000000000000000000000000000000000000000000000000000000000085d", + "0x000000000000000000000000000000000000000000000000000000000000085e", + "0x000000000000000000000000000000000000000000000000000000000000085f", + "0x0000000000000000000000000000000000000000000000000000000000000860", + "0x0000000000000000000000000000000000000000000000000000000000000861", + "0x0000000000000000000000000000000000000000000000000000000000000862", + "0x0000000000000000000000000000000000000000000000000000000000000863", + "0x0000000000000000000000000000000000000000000000000000000000000864", + "0x0000000000000000000000000000000000000000000000000000000000000865", + "0x0000000000000000000000000000000000000000000000000000000000000866", + "0x0000000000000000000000000000000000000000000000000000000000000867", + "0x0000000000000000000000000000000000000000000000000000000000000868", + "0x0000000000000000000000000000000000000000000000000000000000000869", + "0x000000000000000000000000000000000000000000000000000000000000086a", + "0x000000000000000000000000000000000000000000000000000000000000086b", + "0x000000000000000000000000000000000000000000000000000000000000086c", + "0x000000000000000000000000000000000000000000000000000000000000086d", + "0x000000000000000000000000000000000000000000000000000000000000086e", + "0x000000000000000000000000000000000000000000000000000000000000086f", + "0x0000000000000000000000000000000000000000000000000000000000000870", + "0x0000000000000000000000000000000000000000000000000000000000000871", + "0x0000000000000000000000000000000000000000000000000000000000000872", + "0x0000000000000000000000000000000000000000000000000000000000000873", + "0x0000000000000000000000000000000000000000000000000000000000000874", + "0x0000000000000000000000000000000000000000000000000000000000000875", + "0x0000000000000000000000000000000000000000000000000000000000000876", + "0x0000000000000000000000000000000000000000000000000000000000000877", + "0x0000000000000000000000000000000000000000000000000000000000000878", + "0x0000000000000000000000000000000000000000000000000000000000000879", + "0x000000000000000000000000000000000000000000000000000000000000087a", + "0x000000000000000000000000000000000000000000000000000000000000087b", + "0x000000000000000000000000000000000000000000000000000000000000087c", + "0x000000000000000000000000000000000000000000000000000000000000087d", + "0x000000000000000000000000000000000000000000000000000000000000087e", + "0x000000000000000000000000000000000000000000000000000000000000087f", + "0x0000000000000000000000000000000000000000000000000000000000000880", + "0x0000000000000000000000000000000000000000000000000000000000000881", + "0x0000000000000000000000000000000000000000000000000000000000000882", + "0x0000000000000000000000000000000000000000000000000000000000000883", + "0x0000000000000000000000000000000000000000000000000000000000000884", + "0x0000000000000000000000000000000000000000000000000000000000000885", + "0x0000000000000000000000000000000000000000000000000000000000000886", + "0x0000000000000000000000000000000000000000000000000000000000000887", + "0x0000000000000000000000000000000000000000000000000000000000000888", + "0x0000000000000000000000000000000000000000000000000000000000000889", + "0x000000000000000000000000000000000000000000000000000000000000088a", + "0x000000000000000000000000000000000000000000000000000000000000088b", + "0x000000000000000000000000000000000000000000000000000000000000088c", + "0x000000000000000000000000000000000000000000000000000000000000088d", + "0x000000000000000000000000000000000000000000000000000000000000088e", + "0x000000000000000000000000000000000000000000000000000000000000088f", + "0x0000000000000000000000000000000000000000000000000000000000000890", + "0x0000000000000000000000000000000000000000000000000000000000000891", + "0x0000000000000000000000000000000000000000000000000000000000000892", + "0x0000000000000000000000000000000000000000000000000000000000000893", + "0x0000000000000000000000000000000000000000000000000000000000000894", + "0x0000000000000000000000000000000000000000000000000000000000000895", + "0x0000000000000000000000000000000000000000000000000000000000000896", + "0x0000000000000000000000000000000000000000000000000000000000000897", + "0x0000000000000000000000000000000000000000000000000000000000000898", + "0x0000000000000000000000000000000000000000000000000000000000000899", + "0x000000000000000000000000000000000000000000000000000000000000089a", + "0x000000000000000000000000000000000000000000000000000000000000089b", + "0x000000000000000000000000000000000000000000000000000000000000089c", + "0x000000000000000000000000000000000000000000000000000000000000089d", + "0x000000000000000000000000000000000000000000000000000000000000089e", + "0x000000000000000000000000000000000000000000000000000000000000089f", + "0x00000000000000000000000000000000000000000000000000000000000008a0", + "0x00000000000000000000000000000000000000000000000000000000000008a1", + "0x00000000000000000000000000000000000000000000000000000000000008a2", + "0x00000000000000000000000000000000000000000000000000000000000008a3", + "0x00000000000000000000000000000000000000000000000000000000000008a4", + "0x00000000000000000000000000000000000000000000000000000000000008a5", + "0x00000000000000000000000000000000000000000000000000000000000008a6", + "0x00000000000000000000000000000000000000000000000000000000000008a7", + "0x00000000000000000000000000000000000000000000000000000000000008a8", + "0x00000000000000000000000000000000000000000000000000000000000008a9", + "0x00000000000000000000000000000000000000000000000000000000000008aa", + "0x00000000000000000000000000000000000000000000000000000000000008ab", + "0x00000000000000000000000000000000000000000000000000000000000008ac", + "0x00000000000000000000000000000000000000000000000000000000000008ad", + "0x00000000000000000000000000000000000000000000000000000000000008ae", + "0x00000000000000000000000000000000000000000000000000000000000008af", + "0x00000000000000000000000000000000000000000000000000000000000008b0", + "0x00000000000000000000000000000000000000000000000000000000000008b1", + "0x00000000000000000000000000000000000000000000000000000000000008b2", + "0x00000000000000000000000000000000000000000000000000000000000008b3", + "0x00000000000000000000000000000000000000000000000000000000000008b4", + "0x00000000000000000000000000000000000000000000000000000000000008b5", + "0x00000000000000000000000000000000000000000000000000000000000008b6", + "0x00000000000000000000000000000000000000000000000000000000000008b7", + "0x00000000000000000000000000000000000000000000000000000000000008b8", + "0x00000000000000000000000000000000000000000000000000000000000008b9", + "0x00000000000000000000000000000000000000000000000000000000000008ba", + "0x00000000000000000000000000000000000000000000000000000000000008bb", + "0x00000000000000000000000000000000000000000000000000000000000008bc", + "0x00000000000000000000000000000000000000000000000000000000000008bd", + "0x00000000000000000000000000000000000000000000000000000000000008be", + "0x00000000000000000000000000000000000000000000000000000000000008bf", + "0x00000000000000000000000000000000000000000000000000000000000008c0", + "0x00000000000000000000000000000000000000000000000000000000000008c1", + "0x00000000000000000000000000000000000000000000000000000000000008c2", + "0x00000000000000000000000000000000000000000000000000000000000008c3", + "0x00000000000000000000000000000000000000000000000000000000000008c4", + "0x00000000000000000000000000000000000000000000000000000000000008c5", + "0x00000000000000000000000000000000000000000000000000000000000008c6", + "0x00000000000000000000000000000000000000000000000000000000000008c7", + "0x00000000000000000000000000000000000000000000000000000000000008c8", + "0x00000000000000000000000000000000000000000000000000000000000008c9", + "0x00000000000000000000000000000000000000000000000000000000000008ca", + "0x00000000000000000000000000000000000000000000000000000000000008cb", + "0x00000000000000000000000000000000000000000000000000000000000008cc", + "0x00000000000000000000000000000000000000000000000000000000000008cd", + "0x00000000000000000000000000000000000000000000000000000000000008ce", + "0x00000000000000000000000000000000000000000000000000000000000008cf", + "0x00000000000000000000000000000000000000000000000000000000000008d0", + "0x00000000000000000000000000000000000000000000000000000000000008d1", + "0x00000000000000000000000000000000000000000000000000000000000008d2", + "0x00000000000000000000000000000000000000000000000000000000000008d3", + "0x00000000000000000000000000000000000000000000000000000000000008d4", + "0x00000000000000000000000000000000000000000000000000000000000008d5", + "0x00000000000000000000000000000000000000000000000000000000000008d6", + "0x00000000000000000000000000000000000000000000000000000000000008d7", + "0x00000000000000000000000000000000000000000000000000000000000008d8", + "0x00000000000000000000000000000000000000000000000000000000000008d9", + "0x00000000000000000000000000000000000000000000000000000000000008da", + "0x00000000000000000000000000000000000000000000000000000000000008db", + "0x00000000000000000000000000000000000000000000000000000000000008dc", + "0x00000000000000000000000000000000000000000000000000000000000008dd", + "0x00000000000000000000000000000000000000000000000000000000000008de", + "0x00000000000000000000000000000000000000000000000000000000000008df", + "0x00000000000000000000000000000000000000000000000000000000000008e0", + "0x00000000000000000000000000000000000000000000000000000000000008e1", + "0x00000000000000000000000000000000000000000000000000000000000008e2", + "0x00000000000000000000000000000000000000000000000000000000000008e3", + "0x00000000000000000000000000000000000000000000000000000000000008e4", + "0x00000000000000000000000000000000000000000000000000000000000008e5", + "0x00000000000000000000000000000000000000000000000000000000000008e6", + "0x00000000000000000000000000000000000000000000000000000000000008e7", + "0x00000000000000000000000000000000000000000000000000000000000008e8", + "0x00000000000000000000000000000000000000000000000000000000000008e9", + "0x00000000000000000000000000000000000000000000000000000000000008ea", + "0x00000000000000000000000000000000000000000000000000000000000008eb", + "0x00000000000000000000000000000000000000000000000000000000000008ec", + "0x00000000000000000000000000000000000000000000000000000000000008ed", + "0x00000000000000000000000000000000000000000000000000000000000008ee", + "0x00000000000000000000000000000000000000000000000000000000000008ef", + "0x00000000000000000000000000000000000000000000000000000000000008f0", + "0x00000000000000000000000000000000000000000000000000000000000008f1", + "0x00000000000000000000000000000000000000000000000000000000000008f2", + "0x00000000000000000000000000000000000000000000000000000000000008f3", + "0x00000000000000000000000000000000000000000000000000000000000008f4", + "0x00000000000000000000000000000000000000000000000000000000000008f5", + "0x00000000000000000000000000000000000000000000000000000000000008f6", + "0x00000000000000000000000000000000000000000000000000000000000008f7", + "0x00000000000000000000000000000000000000000000000000000000000008f8", + "0x00000000000000000000000000000000000000000000000000000000000008f9", + "0x00000000000000000000000000000000000000000000000000000000000008fa", + "0x00000000000000000000000000000000000000000000000000000000000008fb", + "0x00000000000000000000000000000000000000000000000000000000000008fc", + "0x00000000000000000000000000000000000000000000000000000000000008fd", + "0x00000000000000000000000000000000000000000000000000000000000008fe", + "0x00000000000000000000000000000000000000000000000000000000000008ff", + "0x0000000000000000000000000000000000000000000000000000000000000900", + "0x0000000000000000000000000000000000000000000000000000000000000901", + "0x0000000000000000000000000000000000000000000000000000000000000902", + "0x0000000000000000000000000000000000000000000000000000000000000903", + "0x0000000000000000000000000000000000000000000000000000000000000904", + "0x0000000000000000000000000000000000000000000000000000000000000905", + "0x0000000000000000000000000000000000000000000000000000000000000906", + "0x0000000000000000000000000000000000000000000000000000000000000907", + "0x0000000000000000000000000000000000000000000000000000000000000908", + "0x0000000000000000000000000000000000000000000000000000000000000909", + "0x000000000000000000000000000000000000000000000000000000000000090a", + "0x000000000000000000000000000000000000000000000000000000000000090b", + "0x000000000000000000000000000000000000000000000000000000000000090c", + "0x000000000000000000000000000000000000000000000000000000000000090d", + "0x000000000000000000000000000000000000000000000000000000000000090e", + "0x000000000000000000000000000000000000000000000000000000000000090f", + "0x0000000000000000000000000000000000000000000000000000000000000910", + "0x0000000000000000000000000000000000000000000000000000000000000911", + "0x0000000000000000000000000000000000000000000000000000000000000912", + "0x0000000000000000000000000000000000000000000000000000000000000913", + "0x0000000000000000000000000000000000000000000000000000000000000914", + "0x0000000000000000000000000000000000000000000000000000000000000915", + "0x0000000000000000000000000000000000000000000000000000000000000916", + "0x0000000000000000000000000000000000000000000000000000000000000917", + "0x0000000000000000000000000000000000000000000000000000000000000918", + "0x0000000000000000000000000000000000000000000000000000000000000919", + "0x000000000000000000000000000000000000000000000000000000000000091a", + "0x000000000000000000000000000000000000000000000000000000000000091b", + "0x000000000000000000000000000000000000000000000000000000000000091c", + "0x000000000000000000000000000000000000000000000000000000000000091d", + "0x000000000000000000000000000000000000000000000000000000000000091e", + "0x000000000000000000000000000000000000000000000000000000000000091f", + "0x0000000000000000000000000000000000000000000000000000000000000920", + "0x0000000000000000000000000000000000000000000000000000000000000921", + "0x0000000000000000000000000000000000000000000000000000000000000922", + "0x0000000000000000000000000000000000000000000000000000000000000923", + "0x0000000000000000000000000000000000000000000000000000000000000924", + "0x0000000000000000000000000000000000000000000000000000000000000925", + "0x0000000000000000000000000000000000000000000000000000000000000926", + "0x0000000000000000000000000000000000000000000000000000000000000927", + "0x0000000000000000000000000000000000000000000000000000000000000928", + "0x0000000000000000000000000000000000000000000000000000000000000929", + "0x000000000000000000000000000000000000000000000000000000000000092a", + "0x000000000000000000000000000000000000000000000000000000000000092b", + "0x000000000000000000000000000000000000000000000000000000000000092c", + "0x000000000000000000000000000000000000000000000000000000000000092d", + "0x000000000000000000000000000000000000000000000000000000000000092e", + "0x000000000000000000000000000000000000000000000000000000000000092f", + "0x0000000000000000000000000000000000000000000000000000000000000930", + "0x0000000000000000000000000000000000000000000000000000000000000931", + "0x0000000000000000000000000000000000000000000000000000000000000932", + "0x0000000000000000000000000000000000000000000000000000000000000933", + "0x0000000000000000000000000000000000000000000000000000000000000934", + "0x0000000000000000000000000000000000000000000000000000000000000935", + "0x0000000000000000000000000000000000000000000000000000000000000936", + "0x0000000000000000000000000000000000000000000000000000000000000937", + "0x0000000000000000000000000000000000000000000000000000000000000938", + "0x0000000000000000000000000000000000000000000000000000000000000939", + "0x000000000000000000000000000000000000000000000000000000000000093a", + "0x000000000000000000000000000000000000000000000000000000000000093b", + "0x000000000000000000000000000000000000000000000000000000000000093c", + "0x000000000000000000000000000000000000000000000000000000000000093d", + "0x000000000000000000000000000000000000000000000000000000000000093e", + "0x000000000000000000000000000000000000000000000000000000000000093f", + "0x0000000000000000000000000000000000000000000000000000000000000940", + "0x0000000000000000000000000000000000000000000000000000000000000941", + "0x0000000000000000000000000000000000000000000000000000000000000942", + "0x0000000000000000000000000000000000000000000000000000000000000943", + "0x0000000000000000000000000000000000000000000000000000000000000944", + "0x0000000000000000000000000000000000000000000000000000000000000945", + "0x0000000000000000000000000000000000000000000000000000000000000946", + "0x0000000000000000000000000000000000000000000000000000000000000947", + "0x0000000000000000000000000000000000000000000000000000000000000948", + "0x0000000000000000000000000000000000000000000000000000000000000949", + "0x000000000000000000000000000000000000000000000000000000000000094a", + "0x000000000000000000000000000000000000000000000000000000000000094b", + "0x000000000000000000000000000000000000000000000000000000000000094c", + "0x000000000000000000000000000000000000000000000000000000000000094d", + "0x000000000000000000000000000000000000000000000000000000000000094e", + "0x000000000000000000000000000000000000000000000000000000000000094f", + "0x0000000000000000000000000000000000000000000000000000000000000950", + "0x0000000000000000000000000000000000000000000000000000000000000951", + "0x0000000000000000000000000000000000000000000000000000000000000952", + "0x0000000000000000000000000000000000000000000000000000000000000953", + "0x0000000000000000000000000000000000000000000000000000000000000954", + "0x0000000000000000000000000000000000000000000000000000000000000955", + "0x0000000000000000000000000000000000000000000000000000000000000956", + "0x0000000000000000000000000000000000000000000000000000000000000957", + "0x0000000000000000000000000000000000000000000000000000000000000958", + "0x0000000000000000000000000000000000000000000000000000000000000959", + "0x000000000000000000000000000000000000000000000000000000000000095a", + "0x000000000000000000000000000000000000000000000000000000000000095b", + "0x000000000000000000000000000000000000000000000000000000000000095c", + "0x000000000000000000000000000000000000000000000000000000000000095d", + "0x000000000000000000000000000000000000000000000000000000000000095e", + "0x000000000000000000000000000000000000000000000000000000000000095f", + "0x0000000000000000000000000000000000000000000000000000000000000960", + "0x0000000000000000000000000000000000000000000000000000000000000961", + "0x0000000000000000000000000000000000000000000000000000000000000962", + "0x0000000000000000000000000000000000000000000000000000000000000963", + "0x0000000000000000000000000000000000000000000000000000000000000964", + "0x0000000000000000000000000000000000000000000000000000000000000965", + "0x0000000000000000000000000000000000000000000000000000000000000966", + "0x0000000000000000000000000000000000000000000000000000000000000967", + "0x0000000000000000000000000000000000000000000000000000000000000968", + "0x0000000000000000000000000000000000000000000000000000000000000969", + "0x000000000000000000000000000000000000000000000000000000000000096a", + "0x000000000000000000000000000000000000000000000000000000000000096b", + "0x000000000000000000000000000000000000000000000000000000000000096c", + "0x000000000000000000000000000000000000000000000000000000000000096d", + "0x000000000000000000000000000000000000000000000000000000000000096e", + "0x000000000000000000000000000000000000000000000000000000000000096f", + "0x0000000000000000000000000000000000000000000000000000000000000970", + "0x0000000000000000000000000000000000000000000000000000000000000971", + "0x0000000000000000000000000000000000000000000000000000000000000972", + "0x0000000000000000000000000000000000000000000000000000000000000973", + "0x0000000000000000000000000000000000000000000000000000000000000974", + "0x0000000000000000000000000000000000000000000000000000000000000975", + "0x0000000000000000000000000000000000000000000000000000000000000976", + "0x0000000000000000000000000000000000000000000000000000000000000977", + "0x0000000000000000000000000000000000000000000000000000000000000978", + "0x0000000000000000000000000000000000000000000000000000000000000979", + "0x000000000000000000000000000000000000000000000000000000000000097a", + "0x000000000000000000000000000000000000000000000000000000000000097b", + "0x000000000000000000000000000000000000000000000000000000000000097c", + "0x000000000000000000000000000000000000000000000000000000000000097d", + "0x000000000000000000000000000000000000000000000000000000000000097e", + "0x000000000000000000000000000000000000000000000000000000000000097f", + "0x0000000000000000000000000000000000000000000000000000000000000980", + "0x0000000000000000000000000000000000000000000000000000000000000981", + "0x0000000000000000000000000000000000000000000000000000000000000982", + "0x0000000000000000000000000000000000000000000000000000000000000983", + "0x0000000000000000000000000000000000000000000000000000000000000984", + "0x0000000000000000000000000000000000000000000000000000000000000985", + "0x0000000000000000000000000000000000000000000000000000000000000986", + "0x0000000000000000000000000000000000000000000000000000000000000987", + "0x0000000000000000000000000000000000000000000000000000000000000988", + "0x0000000000000000000000000000000000000000000000000000000000000989", + "0x000000000000000000000000000000000000000000000000000000000000098a", + "0x000000000000000000000000000000000000000000000000000000000000098b", + "0x000000000000000000000000000000000000000000000000000000000000098c", + "0x000000000000000000000000000000000000000000000000000000000000098d", + "0x000000000000000000000000000000000000000000000000000000000000098e", + "0x000000000000000000000000000000000000000000000000000000000000098f", + "0x0000000000000000000000000000000000000000000000000000000000000990", + "0x0000000000000000000000000000000000000000000000000000000000000991", + "0x0000000000000000000000000000000000000000000000000000000000000992", + "0x0000000000000000000000000000000000000000000000000000000000000993", + "0x0000000000000000000000000000000000000000000000000000000000000994", + "0x0000000000000000000000000000000000000000000000000000000000000995", + "0x0000000000000000000000000000000000000000000000000000000000000996", + "0x0000000000000000000000000000000000000000000000000000000000000997", + "0x0000000000000000000000000000000000000000000000000000000000000998", + "0x0000000000000000000000000000000000000000000000000000000000000999", + "0x000000000000000000000000000000000000000000000000000000000000099a", + "0x000000000000000000000000000000000000000000000000000000000000099b", + "0x000000000000000000000000000000000000000000000000000000000000099c", + "0x000000000000000000000000000000000000000000000000000000000000099d", + "0x000000000000000000000000000000000000000000000000000000000000099e", + "0x000000000000000000000000000000000000000000000000000000000000099f", + "0x00000000000000000000000000000000000000000000000000000000000009a0", + "0x00000000000000000000000000000000000000000000000000000000000009a1", + "0x00000000000000000000000000000000000000000000000000000000000009a2", + "0x00000000000000000000000000000000000000000000000000000000000009a3", + "0x00000000000000000000000000000000000000000000000000000000000009a4", + "0x00000000000000000000000000000000000000000000000000000000000009a5", + "0x00000000000000000000000000000000000000000000000000000000000009a6", + "0x00000000000000000000000000000000000000000000000000000000000009a7", + "0x00000000000000000000000000000000000000000000000000000000000009a8", + "0x00000000000000000000000000000000000000000000000000000000000009a9", + "0x00000000000000000000000000000000000000000000000000000000000009aa", + "0x00000000000000000000000000000000000000000000000000000000000009ab", + "0x00000000000000000000000000000000000000000000000000000000000009ac", + "0x00000000000000000000000000000000000000000000000000000000000009ad", + "0x00000000000000000000000000000000000000000000000000000000000009ae", + "0x00000000000000000000000000000000000000000000000000000000000009af", + "0x00000000000000000000000000000000000000000000000000000000000009b0", + "0x00000000000000000000000000000000000000000000000000000000000009b1", + "0x00000000000000000000000000000000000000000000000000000000000009b2", + "0x00000000000000000000000000000000000000000000000000000000000009b3", + "0x00000000000000000000000000000000000000000000000000000000000009b4", + "0x00000000000000000000000000000000000000000000000000000000000009b5", + "0x00000000000000000000000000000000000000000000000000000000000009b6", + "0x00000000000000000000000000000000000000000000000000000000000009b7", + "0x00000000000000000000000000000000000000000000000000000000000009b8", + "0x00000000000000000000000000000000000000000000000000000000000009b9", + "0x00000000000000000000000000000000000000000000000000000000000009ba", + "0x00000000000000000000000000000000000000000000000000000000000009bb", + "0x00000000000000000000000000000000000000000000000000000000000009bc", + "0x00000000000000000000000000000000000000000000000000000000000009bd", + "0x00000000000000000000000000000000000000000000000000000000000009be", + "0x00000000000000000000000000000000000000000000000000000000000009bf", + "0x00000000000000000000000000000000000000000000000000000000000009c0", + "0x00000000000000000000000000000000000000000000000000000000000009c1", + "0x00000000000000000000000000000000000000000000000000000000000009c2", + "0x00000000000000000000000000000000000000000000000000000000000009c3", + "0x00000000000000000000000000000000000000000000000000000000000009c4", + "0x00000000000000000000000000000000000000000000000000000000000009c5", + "0x00000000000000000000000000000000000000000000000000000000000009c6", + "0x00000000000000000000000000000000000000000000000000000000000009c7", + "0x00000000000000000000000000000000000000000000000000000000000009c8", + "0x00000000000000000000000000000000000000000000000000000000000009c9", + "0x00000000000000000000000000000000000000000000000000000000000009ca", + "0x00000000000000000000000000000000000000000000000000000000000009cb", + "0x00000000000000000000000000000000000000000000000000000000000009cc", + "0x00000000000000000000000000000000000000000000000000000000000009cd", + "0x00000000000000000000000000000000000000000000000000000000000009ce", + "0x00000000000000000000000000000000000000000000000000000000000009cf", + "0x00000000000000000000000000000000000000000000000000000000000009d0", + "0x00000000000000000000000000000000000000000000000000000000000009d1", + "0x00000000000000000000000000000000000000000000000000000000000009d2", + "0x00000000000000000000000000000000000000000000000000000000000009d3", + "0x00000000000000000000000000000000000000000000000000000000000009d4", + "0x00000000000000000000000000000000000000000000000000000000000009d5", + "0x00000000000000000000000000000000000000000000000000000000000009d6", + "0x00000000000000000000000000000000000000000000000000000000000009d7", + "0x00000000000000000000000000000000000000000000000000000000000009d8", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da", + "0x00000000000000000000000000000000000000000000000000000000000009db" +] + num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400" + num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400" + [inputs.previous_l1_to_l2] root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000001800" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first/Prover.toml index 59d039325c74..e5606c54742f 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-first/Prover.toml @@ -1,5 +1,15 @@ [inputs] -new_l1_to_l2_message_subtree_root_sibling_path = [ +l1_to_l2_message_frontier_hint = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f", "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad", "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da", @@ -28,10 +38,10 @@ new_l1_to_l2_message_subtree_root_sibling_path = [ "0x0aced6fe68143f4c7acd16345a8c1bb50c51a0692b760eb48728feb923d90757" ] new_archive_sibling_path = [ - "0x01cbead9c751274331efa8f9a57e37296af41dfda8fde8b9dfad15e6df101932", + "0x03f4c32538d42652fb32a5cb2aee4307443fe38382028580e7aa46e43182df55", "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb", - "0x26a143f9222c4ce37939deed6bf5daaa3020d99712c72f9303b3df89e6ce47fe", - "0x09308d0807f5aed64dd43d2014519a161c32f9a52ea75992cc18bec0bcde410e", + "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d", + "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037", "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da", "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249", "0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f", @@ -60,558 +70,6 @@ new_archive_sibling_path = [ "0x2aad701e57c7069cb4e148d971c0eae9ac7429d7d833c51d87875ead0c5aca3c" ] - [inputs.parity_root] - proof = [ - "0x0000000000000000000000000000000000000000000000000000000000000001", - "0x0000000000000000000000000000000000000000000000000000000000000002", - "0x0000000000000000000000000000000000000000000000000000000000000003", - "0x0000000000000000000000000000000000000000000000000000000000000004", - "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x0000000000000000000000000000000000000000000000000000000000000006", - "0x0000000000000000000000000000000000000000000000000000000000000007", - "0x0000000000000000000000000000000000000000000000000000000000000008", - "0x0000000000000000000000000000000000000000000000000000000000000009", - "0x000000000000000000000000000000000000000000000000000000000000000a", - "0x000000000000000000000000000000000000000000000000000000000000000b", - "0x000000000000000000000000000000000000000000000000000000000000000c", - "0x000000000000000000000000000000000000000000000000000000000000000d", - "0x000000000000000000000000000000000000000000000000000000000000000e", - "0x000000000000000000000000000000000000000000000000000000000000000f", - "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x0000000000000000000000000000000000000000000000000000000000000011", - "0x0000000000000000000000000000000000000000000000000000000000000012", - "0x0000000000000000000000000000000000000000000000000000000000000013", - "0x0000000000000000000000000000000000000000000000000000000000000014", - "0x0000000000000000000000000000000000000000000000000000000000000015", - "0x0000000000000000000000000000000000000000000000000000000000000016", - "0x0000000000000000000000000000000000000000000000000000000000000017", - "0x0000000000000000000000000000000000000000000000000000000000000018", - "0x0000000000000000000000000000000000000000000000000000000000000019", - "0x000000000000000000000000000000000000000000000000000000000000001a", - "0x000000000000000000000000000000000000000000000000000000000000001b", - "0x000000000000000000000000000000000000000000000000000000000000001c", - "0x000000000000000000000000000000000000000000000000000000000000001d", - "0x000000000000000000000000000000000000000000000000000000000000001e", - "0x000000000000000000000000000000000000000000000000000000000000001f", - "0x0000000000000000000000000000000000000000000000000000000000000020", - "0x0000000000000000000000000000000000000000000000000000000000000021", - "0x0000000000000000000000000000000000000000000000000000000000000022", - "0x0000000000000000000000000000000000000000000000000000000000000023", - "0x0000000000000000000000000000000000000000000000000000000000000024", - "0x0000000000000000000000000000000000000000000000000000000000000025", - "0x0000000000000000000000000000000000000000000000000000000000000026", - "0x0000000000000000000000000000000000000000000000000000000000000027", - "0x0000000000000000000000000000000000000000000000000000000000000028", - "0x0000000000000000000000000000000000000000000000000000000000000029", - "0x000000000000000000000000000000000000000000000000000000000000002a", - "0x000000000000000000000000000000000000000000000000000000000000002b", - "0x000000000000000000000000000000000000000000000000000000000000002c", - "0x000000000000000000000000000000000000000000000000000000000000002d", - "0x000000000000000000000000000000000000000000000000000000000000002e", - "0x000000000000000000000000000000000000000000000000000000000000002f", - "0x0000000000000000000000000000000000000000000000000000000000000030", - "0x0000000000000000000000000000000000000000000000000000000000000031", - "0x0000000000000000000000000000000000000000000000000000000000000032", - "0x0000000000000000000000000000000000000000000000000000000000000033", - "0x0000000000000000000000000000000000000000000000000000000000000034", - "0x0000000000000000000000000000000000000000000000000000000000000035", - "0x0000000000000000000000000000000000000000000000000000000000000036", - "0x0000000000000000000000000000000000000000000000000000000000000037", - "0x0000000000000000000000000000000000000000000000000000000000000038", - "0x0000000000000000000000000000000000000000000000000000000000000039", - "0x000000000000000000000000000000000000000000000000000000000000003a", - "0x000000000000000000000000000000000000000000000000000000000000003b", - "0x000000000000000000000000000000000000000000000000000000000000003c", - "0x000000000000000000000000000000000000000000000000000000000000003d", - "0x000000000000000000000000000000000000000000000000000000000000003e", - "0x000000000000000000000000000000000000000000000000000000000000003f", - "0x0000000000000000000000000000000000000000000000000000000000000040", - "0x0000000000000000000000000000000000000000000000000000000000000041", - "0x0000000000000000000000000000000000000000000000000000000000000042", - "0x0000000000000000000000000000000000000000000000000000000000000043", - "0x0000000000000000000000000000000000000000000000000000000000000044", - "0x0000000000000000000000000000000000000000000000000000000000000045", - "0x0000000000000000000000000000000000000000000000000000000000000046", - "0x0000000000000000000000000000000000000000000000000000000000000047", - "0x0000000000000000000000000000000000000000000000000000000000000048", - "0x0000000000000000000000000000000000000000000000000000000000000049", - "0x000000000000000000000000000000000000000000000000000000000000004a", - "0x000000000000000000000000000000000000000000000000000000000000004b", - "0x000000000000000000000000000000000000000000000000000000000000004c", - "0x000000000000000000000000000000000000000000000000000000000000004d", - "0x000000000000000000000000000000000000000000000000000000000000004e", - "0x000000000000000000000000000000000000000000000000000000000000004f", - "0x0000000000000000000000000000000000000000000000000000000000000050", - "0x0000000000000000000000000000000000000000000000000000000000000051", - "0x0000000000000000000000000000000000000000000000000000000000000052", - "0x0000000000000000000000000000000000000000000000000000000000000053", - "0x0000000000000000000000000000000000000000000000000000000000000054", - "0x0000000000000000000000000000000000000000000000000000000000000055", - "0x0000000000000000000000000000000000000000000000000000000000000056", - "0x0000000000000000000000000000000000000000000000000000000000000057", - "0x0000000000000000000000000000000000000000000000000000000000000058", - "0x0000000000000000000000000000000000000000000000000000000000000059", - "0x000000000000000000000000000000000000000000000000000000000000005a", - "0x000000000000000000000000000000000000000000000000000000000000005b", - "0x000000000000000000000000000000000000000000000000000000000000005c", - "0x000000000000000000000000000000000000000000000000000000000000005d", - "0x000000000000000000000000000000000000000000000000000000000000005e", - "0x000000000000000000000000000000000000000000000000000000000000005f", - "0x0000000000000000000000000000000000000000000000000000000000000060", - "0x0000000000000000000000000000000000000000000000000000000000000061", - "0x0000000000000000000000000000000000000000000000000000000000000062", - "0x0000000000000000000000000000000000000000000000000000000000000063", - "0x0000000000000000000000000000000000000000000000000000000000000064", - "0x0000000000000000000000000000000000000000000000000000000000000065", - "0x0000000000000000000000000000000000000000000000000000000000000066", - "0x0000000000000000000000000000000000000000000000000000000000000067", - "0x0000000000000000000000000000000000000000000000000000000000000068", - "0x0000000000000000000000000000000000000000000000000000000000000069", - "0x000000000000000000000000000000000000000000000000000000000000006a", - "0x000000000000000000000000000000000000000000000000000000000000006b", - "0x000000000000000000000000000000000000000000000000000000000000006c", - "0x000000000000000000000000000000000000000000000000000000000000006d", - "0x000000000000000000000000000000000000000000000000000000000000006e", - "0x000000000000000000000000000000000000000000000000000000000000006f", - "0x0000000000000000000000000000000000000000000000000000000000000070", - "0x0000000000000000000000000000000000000000000000000000000000000071", - "0x0000000000000000000000000000000000000000000000000000000000000072", - "0x0000000000000000000000000000000000000000000000000000000000000073", - "0x0000000000000000000000000000000000000000000000000000000000000074", - "0x0000000000000000000000000000000000000000000000000000000000000075", - "0x0000000000000000000000000000000000000000000000000000000000000076", - "0x0000000000000000000000000000000000000000000000000000000000000077", - "0x0000000000000000000000000000000000000000000000000000000000000078", - "0x0000000000000000000000000000000000000000000000000000000000000079", - "0x000000000000000000000000000000000000000000000000000000000000007a", - "0x000000000000000000000000000000000000000000000000000000000000007b", - "0x000000000000000000000000000000000000000000000000000000000000007c", - "0x000000000000000000000000000000000000000000000000000000000000007d", - "0x000000000000000000000000000000000000000000000000000000000000007e", - "0x000000000000000000000000000000000000000000000000000000000000007f", - "0x0000000000000000000000000000000000000000000000000000000000000080", - "0x0000000000000000000000000000000000000000000000000000000000000081", - "0x0000000000000000000000000000000000000000000000000000000000000082", - "0x0000000000000000000000000000000000000000000000000000000000000083", - "0x0000000000000000000000000000000000000000000000000000000000000084", - "0x0000000000000000000000000000000000000000000000000000000000000085", - "0x0000000000000000000000000000000000000000000000000000000000000086", - "0x0000000000000000000000000000000000000000000000000000000000000087", - "0x0000000000000000000000000000000000000000000000000000000000000088", - "0x0000000000000000000000000000000000000000000000000000000000000089", - "0x000000000000000000000000000000000000000000000000000000000000008a", - "0x000000000000000000000000000000000000000000000000000000000000008b", - "0x000000000000000000000000000000000000000000000000000000000000008c", - "0x000000000000000000000000000000000000000000000000000000000000008d", - "0x000000000000000000000000000000000000000000000000000000000000008e", - "0x000000000000000000000000000000000000000000000000000000000000008f", - "0x0000000000000000000000000000000000000000000000000000000000000090", - "0x0000000000000000000000000000000000000000000000000000000000000091", - "0x0000000000000000000000000000000000000000000000000000000000000092", - "0x0000000000000000000000000000000000000000000000000000000000000093", - "0x0000000000000000000000000000000000000000000000000000000000000094", - "0x0000000000000000000000000000000000000000000000000000000000000095", - "0x0000000000000000000000000000000000000000000000000000000000000096", - "0x0000000000000000000000000000000000000000000000000000000000000097", - "0x0000000000000000000000000000000000000000000000000000000000000098", - "0x0000000000000000000000000000000000000000000000000000000000000099", - "0x000000000000000000000000000000000000000000000000000000000000009a", - "0x000000000000000000000000000000000000000000000000000000000000009b", - "0x000000000000000000000000000000000000000000000000000000000000009c", - "0x000000000000000000000000000000000000000000000000000000000000009d", - "0x000000000000000000000000000000000000000000000000000000000000009e", - "0x000000000000000000000000000000000000000000000000000000000000009f", - "0x00000000000000000000000000000000000000000000000000000000000000a0", - "0x00000000000000000000000000000000000000000000000000000000000000a1", - "0x00000000000000000000000000000000000000000000000000000000000000a2", - "0x00000000000000000000000000000000000000000000000000000000000000a3", - "0x00000000000000000000000000000000000000000000000000000000000000a4", - "0x00000000000000000000000000000000000000000000000000000000000000a5", - "0x00000000000000000000000000000000000000000000000000000000000000a6", - "0x00000000000000000000000000000000000000000000000000000000000000a7", - "0x00000000000000000000000000000000000000000000000000000000000000a8", - "0x00000000000000000000000000000000000000000000000000000000000000a9", - "0x00000000000000000000000000000000000000000000000000000000000000aa", - "0x00000000000000000000000000000000000000000000000000000000000000ab", - "0x00000000000000000000000000000000000000000000000000000000000000ac", - "0x00000000000000000000000000000000000000000000000000000000000000ad", - "0x00000000000000000000000000000000000000000000000000000000000000ae", - "0x00000000000000000000000000000000000000000000000000000000000000af", - "0x00000000000000000000000000000000000000000000000000000000000000b0", - "0x00000000000000000000000000000000000000000000000000000000000000b1", - "0x00000000000000000000000000000000000000000000000000000000000000b2", - "0x00000000000000000000000000000000000000000000000000000000000000b3", - "0x00000000000000000000000000000000000000000000000000000000000000b4", - "0x00000000000000000000000000000000000000000000000000000000000000b5", - "0x00000000000000000000000000000000000000000000000000000000000000b6", - "0x00000000000000000000000000000000000000000000000000000000000000b7", - "0x00000000000000000000000000000000000000000000000000000000000000b8", - "0x00000000000000000000000000000000000000000000000000000000000000b9", - "0x00000000000000000000000000000000000000000000000000000000000000ba", - "0x00000000000000000000000000000000000000000000000000000000000000bb", - "0x00000000000000000000000000000000000000000000000000000000000000bc", - "0x00000000000000000000000000000000000000000000000000000000000000bd", - "0x00000000000000000000000000000000000000000000000000000000000000be", - "0x00000000000000000000000000000000000000000000000000000000000000bf", - "0x00000000000000000000000000000000000000000000000000000000000000c0", - "0x00000000000000000000000000000000000000000000000000000000000000c1", - "0x00000000000000000000000000000000000000000000000000000000000000c2", - "0x00000000000000000000000000000000000000000000000000000000000000c3", - "0x00000000000000000000000000000000000000000000000000000000000000c4", - "0x00000000000000000000000000000000000000000000000000000000000000c5", - "0x00000000000000000000000000000000000000000000000000000000000000c6", - "0x00000000000000000000000000000000000000000000000000000000000000c7", - "0x00000000000000000000000000000000000000000000000000000000000000c8", - "0x00000000000000000000000000000000000000000000000000000000000000c9", - "0x00000000000000000000000000000000000000000000000000000000000000ca", - "0x00000000000000000000000000000000000000000000000000000000000000cb", - "0x00000000000000000000000000000000000000000000000000000000000000cc", - "0x00000000000000000000000000000000000000000000000000000000000000cd", - "0x00000000000000000000000000000000000000000000000000000000000000ce", - "0x00000000000000000000000000000000000000000000000000000000000000cf", - "0x00000000000000000000000000000000000000000000000000000000000000d0", - "0x00000000000000000000000000000000000000000000000000000000000000d1", - "0x00000000000000000000000000000000000000000000000000000000000000d2", - "0x00000000000000000000000000000000000000000000000000000000000000d3", - "0x00000000000000000000000000000000000000000000000000000000000000d4", - "0x00000000000000000000000000000000000000000000000000000000000000d5", - "0x00000000000000000000000000000000000000000000000000000000000000d6", - "0x00000000000000000000000000000000000000000000000000000000000000d7", - "0x00000000000000000000000000000000000000000000000000000000000000d8", - "0x00000000000000000000000000000000000000000000000000000000000000d9", - "0x00000000000000000000000000000000000000000000000000000000000000da", - "0x00000000000000000000000000000000000000000000000000000000000000db", - "0x00000000000000000000000000000000000000000000000000000000000000dc", - "0x00000000000000000000000000000000000000000000000000000000000000dd", - "0x00000000000000000000000000000000000000000000000000000000000000de", - "0x00000000000000000000000000000000000000000000000000000000000000df", - "0x00000000000000000000000000000000000000000000000000000000000000e0", - "0x00000000000000000000000000000000000000000000000000000000000000e1", - "0x00000000000000000000000000000000000000000000000000000000000000e2", - "0x00000000000000000000000000000000000000000000000000000000000000e3", - "0x00000000000000000000000000000000000000000000000000000000000000e4", - "0x00000000000000000000000000000000000000000000000000000000000000e5", - "0x00000000000000000000000000000000000000000000000000000000000000e6", - "0x00000000000000000000000000000000000000000000000000000000000000e7", - "0x00000000000000000000000000000000000000000000000000000000000000e8", - "0x00000000000000000000000000000000000000000000000000000000000000e9", - "0x00000000000000000000000000000000000000000000000000000000000000ea", - "0x00000000000000000000000000000000000000000000000000000000000000eb", - "0x00000000000000000000000000000000000000000000000000000000000000ec", - "0x00000000000000000000000000000000000000000000000000000000000000ed", - "0x00000000000000000000000000000000000000000000000000000000000000ee", - "0x00000000000000000000000000000000000000000000000000000000000000ef", - "0x00000000000000000000000000000000000000000000000000000000000000f0", - "0x00000000000000000000000000000000000000000000000000000000000000f1", - "0x00000000000000000000000000000000000000000000000000000000000000f2", - "0x00000000000000000000000000000000000000000000000000000000000000f3", - "0x00000000000000000000000000000000000000000000000000000000000000f4", - "0x00000000000000000000000000000000000000000000000000000000000000f5", - "0x00000000000000000000000000000000000000000000000000000000000000f6", - "0x00000000000000000000000000000000000000000000000000000000000000f7", - "0x00000000000000000000000000000000000000000000000000000000000000f8", - "0x00000000000000000000000000000000000000000000000000000000000000f9", - "0x00000000000000000000000000000000000000000000000000000000000000fa", - "0x00000000000000000000000000000000000000000000000000000000000000fb", - "0x00000000000000000000000000000000000000000000000000000000000000fc", - "0x00000000000000000000000000000000000000000000000000000000000000fd", - "0x00000000000000000000000000000000000000000000000000000000000000fe", - "0x00000000000000000000000000000000000000000000000000000000000000ff", - "0x0000000000000000000000000000000000000000000000000000000000000100", - "0x0000000000000000000000000000000000000000000000000000000000000101", - "0x0000000000000000000000000000000000000000000000000000000000000102", - "0x0000000000000000000000000000000000000000000000000000000000000103", - "0x0000000000000000000000000000000000000000000000000000000000000104", - "0x0000000000000000000000000000000000000000000000000000000000000105", - "0x0000000000000000000000000000000000000000000000000000000000000106", - "0x0000000000000000000000000000000000000000000000000000000000000107", - "0x0000000000000000000000000000000000000000000000000000000000000108", - "0x0000000000000000000000000000000000000000000000000000000000000109", - "0x000000000000000000000000000000000000000000000000000000000000010a", - "0x000000000000000000000000000000000000000000000000000000000000010b", - "0x000000000000000000000000000000000000000000000000000000000000010c", - "0x000000000000000000000000000000000000000000000000000000000000010d", - "0x000000000000000000000000000000000000000000000000000000000000010e", - "0x000000000000000000000000000000000000000000000000000000000000010f", - "0x0000000000000000000000000000000000000000000000000000000000000110", - "0x0000000000000000000000000000000000000000000000000000000000000111", - "0x0000000000000000000000000000000000000000000000000000000000000112", - "0x0000000000000000000000000000000000000000000000000000000000000113", - "0x0000000000000000000000000000000000000000000000000000000000000114", - "0x0000000000000000000000000000000000000000000000000000000000000115", - "0x0000000000000000000000000000000000000000000000000000000000000116", - "0x0000000000000000000000000000000000000000000000000000000000000117", - "0x0000000000000000000000000000000000000000000000000000000000000118", - "0x0000000000000000000000000000000000000000000000000000000000000119", - "0x000000000000000000000000000000000000000000000000000000000000011a", - "0x000000000000000000000000000000000000000000000000000000000000011b", - "0x000000000000000000000000000000000000000000000000000000000000011c", - "0x000000000000000000000000000000000000000000000000000000000000011d", - "0x000000000000000000000000000000000000000000000000000000000000011e", - "0x000000000000000000000000000000000000000000000000000000000000011f", - "0x0000000000000000000000000000000000000000000000000000000000000120", - "0x0000000000000000000000000000000000000000000000000000000000000121", - "0x0000000000000000000000000000000000000000000000000000000000000122", - "0x0000000000000000000000000000000000000000000000000000000000000123", - "0x0000000000000000000000000000000000000000000000000000000000000124", - "0x0000000000000000000000000000000000000000000000000000000000000125", - "0x0000000000000000000000000000000000000000000000000000000000000126", - "0x0000000000000000000000000000000000000000000000000000000000000127", - "0x0000000000000000000000000000000000000000000000000000000000000128", - "0x0000000000000000000000000000000000000000000000000000000000000129", - "0x000000000000000000000000000000000000000000000000000000000000012a", - "0x000000000000000000000000000000000000000000000000000000000000012b", - "0x000000000000000000000000000000000000000000000000000000000000012c", - "0x000000000000000000000000000000000000000000000000000000000000012d", - "0x000000000000000000000000000000000000000000000000000000000000012e", - "0x000000000000000000000000000000000000000000000000000000000000012f", - "0x0000000000000000000000000000000000000000000000000000000000000130", - "0x0000000000000000000000000000000000000000000000000000000000000131", - "0x0000000000000000000000000000000000000000000000000000000000000132", - "0x0000000000000000000000000000000000000000000000000000000000000133", - "0x0000000000000000000000000000000000000000000000000000000000000134", - "0x0000000000000000000000000000000000000000000000000000000000000135", - "0x0000000000000000000000000000000000000000000000000000000000000136", - "0x0000000000000000000000000000000000000000000000000000000000000137", - "0x0000000000000000000000000000000000000000000000000000000000000138", - "0x0000000000000000000000000000000000000000000000000000000000000139", - "0x000000000000000000000000000000000000000000000000000000000000013a", - "0x000000000000000000000000000000000000000000000000000000000000013b", - "0x000000000000000000000000000000000000000000000000000000000000013c", - "0x000000000000000000000000000000000000000000000000000000000000013d", - "0x000000000000000000000000000000000000000000000000000000000000013e", - "0x000000000000000000000000000000000000000000000000000000000000013f", - "0x0000000000000000000000000000000000000000000000000000000000000140", - "0x0000000000000000000000000000000000000000000000000000000000000141", - "0x0000000000000000000000000000000000000000000000000000000000000142", - "0x0000000000000000000000000000000000000000000000000000000000000143", - "0x0000000000000000000000000000000000000000000000000000000000000144", - "0x0000000000000000000000000000000000000000000000000000000000000145", - "0x0000000000000000000000000000000000000000000000000000000000000146", - "0x0000000000000000000000000000000000000000000000000000000000000147", - "0x0000000000000000000000000000000000000000000000000000000000000148", - "0x0000000000000000000000000000000000000000000000000000000000000149", - "0x000000000000000000000000000000000000000000000000000000000000014a", - "0x000000000000000000000000000000000000000000000000000000000000014b", - "0x000000000000000000000000000000000000000000000000000000000000014c", - "0x000000000000000000000000000000000000000000000000000000000000014d", - "0x000000000000000000000000000000000000000000000000000000000000014e", - "0x000000000000000000000000000000000000000000000000000000000000014f", - "0x0000000000000000000000000000000000000000000000000000000000000150", - "0x0000000000000000000000000000000000000000000000000000000000000151", - "0x0000000000000000000000000000000000000000000000000000000000000152", - "0x0000000000000000000000000000000000000000000000000000000000000153", - "0x0000000000000000000000000000000000000000000000000000000000000154", - "0x0000000000000000000000000000000000000000000000000000000000000155", - "0x0000000000000000000000000000000000000000000000000000000000000156", - "0x0000000000000000000000000000000000000000000000000000000000000157", - "0x0000000000000000000000000000000000000000000000000000000000000158", - "0x0000000000000000000000000000000000000000000000000000000000000159", - "0x000000000000000000000000000000000000000000000000000000000000015a", - "0x000000000000000000000000000000000000000000000000000000000000015b", - "0x000000000000000000000000000000000000000000000000000000000000015c", - "0x000000000000000000000000000000000000000000000000000000000000015d", - "0x000000000000000000000000000000000000000000000000000000000000015e", - "0x000000000000000000000000000000000000000000000000000000000000015f", - "0x0000000000000000000000000000000000000000000000000000000000000160", - "0x0000000000000000000000000000000000000000000000000000000000000161", - "0x0000000000000000000000000000000000000000000000000000000000000162", - "0x0000000000000000000000000000000000000000000000000000000000000163", - "0x0000000000000000000000000000000000000000000000000000000000000164", - "0x0000000000000000000000000000000000000000000000000000000000000165", - "0x0000000000000000000000000000000000000000000000000000000000000166", - "0x0000000000000000000000000000000000000000000000000000000000000167", - "0x0000000000000000000000000000000000000000000000000000000000000168", - "0x0000000000000000000000000000000000000000000000000000000000000169", - "0x000000000000000000000000000000000000000000000000000000000000016a", - "0x000000000000000000000000000000000000000000000000000000000000016b", - "0x000000000000000000000000000000000000000000000000000000000000016c", - "0x000000000000000000000000000000000000000000000000000000000000016d", - "0x000000000000000000000000000000000000000000000000000000000000016e", - "0x000000000000000000000000000000000000000000000000000000000000016f", - "0x0000000000000000000000000000000000000000000000000000000000000170", - "0x0000000000000000000000000000000000000000000000000000000000000171", - "0x0000000000000000000000000000000000000000000000000000000000000172", - "0x0000000000000000000000000000000000000000000000000000000000000173", - "0x0000000000000000000000000000000000000000000000000000000000000174", - "0x0000000000000000000000000000000000000000000000000000000000000175", - "0x0000000000000000000000000000000000000000000000000000000000000176", - "0x0000000000000000000000000000000000000000000000000000000000000177", - "0x0000000000000000000000000000000000000000000000000000000000000178", - "0x0000000000000000000000000000000000000000000000000000000000000179", - "0x000000000000000000000000000000000000000000000000000000000000017a", - "0x000000000000000000000000000000000000000000000000000000000000017b", - "0x000000000000000000000000000000000000000000000000000000000000017c", - "0x000000000000000000000000000000000000000000000000000000000000017d", - "0x000000000000000000000000000000000000000000000000000000000000017e", - "0x000000000000000000000000000000000000000000000000000000000000017f", - "0x0000000000000000000000000000000000000000000000000000000000000180", - "0x0000000000000000000000000000000000000000000000000000000000000181", - "0x0000000000000000000000000000000000000000000000000000000000000182", - "0x0000000000000000000000000000000000000000000000000000000000000183", - "0x0000000000000000000000000000000000000000000000000000000000000184", - "0x0000000000000000000000000000000000000000000000000000000000000185", - "0x0000000000000000000000000000000000000000000000000000000000000186", - "0x0000000000000000000000000000000000000000000000000000000000000187", - "0x0000000000000000000000000000000000000000000000000000000000000188", - "0x0000000000000000000000000000000000000000000000000000000000000189", - "0x000000000000000000000000000000000000000000000000000000000000018a", - "0x000000000000000000000000000000000000000000000000000000000000018b", - "0x000000000000000000000000000000000000000000000000000000000000018c", - "0x000000000000000000000000000000000000000000000000000000000000018d", - "0x000000000000000000000000000000000000000000000000000000000000018e", - "0x000000000000000000000000000000000000000000000000000000000000018f", - "0x0000000000000000000000000000000000000000000000000000000000000190", - "0x0000000000000000000000000000000000000000000000000000000000000191", - "0x0000000000000000000000000000000000000000000000000000000000000192", - "0x0000000000000000000000000000000000000000000000000000000000000193", - "0x0000000000000000000000000000000000000000000000000000000000000194", - "0x0000000000000000000000000000000000000000000000000000000000000195", - "0x0000000000000000000000000000000000000000000000000000000000000196", - "0x0000000000000000000000000000000000000000000000000000000000000197", - "0x0000000000000000000000000000000000000000000000000000000000000198", - "0x0000000000000000000000000000000000000000000000000000000000000199", - "0x000000000000000000000000000000000000000000000000000000000000019a" -] - - [inputs.parity_root.public_inputs] - sha_root = "0x00de7b349d2306334734e4f58b1302a6ed5a6c796a706f6597a5641b6d468223" - converted_root = "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f" - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" - - [inputs.parity_root.vk_data] - leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000016" - sibling_path = [ - "0x005a4d59d6486e10a3eefab398cca5d3c8e89e178a566d9885c5d7e478e46338", - "0x1fa32700cbe47fec502423d9419340fdfc6b73c146a1b1e42189b4dee5ddb4cc", - "0x07250f720369414b8956bab70d3dbfbe4a5912f128405eedb1c920009dcea92c", - "0x033c4d295fe10d44c10ab7dd6b98731454b30ab8a3b175477338750c07bc4023", - "0x234c347546637311dad66534e5274a6a5db5da51b51baab040dac88807024ce5", - "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" -] - - [inputs.parity_root.vk_data.vk] - key = [ - "0x0000000000000000000000000000000000000000000000000000000000000016", - "0x000000000000000000000000000000000000000000000000000000000000000c", - "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x00000000000000000000000000000051b95d468aa9edbdd7a1e0f23a986c062f", - "0x00000000000000000000000000000000001bad5c453d035ced539f73b9ad9856", - "0x000000000000000000000000000000b9f20b33b45f2cd16ad5d036ab4e3b3e29", - "0x000000000000000000000000000000000024ea357fc8a07811c9d33358737ae6", - "0x000000000000000000000000000000ecd08e9e55edf496bac0902ec569099076", - "0x00000000000000000000000000000000002545be4c6d35893482ac43aecf9ca3", - "0x0000000000000000000000000000007b0429d81df3d0e6f023ad3023885f5d80", - "0x00000000000000000000000000000000001c682d1353fe66ef71491f339cde4c", - "0x00000000000000000000000000000021d27796a33c109672b6cdddafb1014772", - "0x00000000000000000000000000000000002cb8cb3972a4653468363f5cb656aa", - "0x000000000000000000000000000000253a50863b978d9398edeaaadb777a07a1", - "0x00000000000000000000000000000000000ef2db12c6ccbb131452091724f6a1", - "0x0000000000000000000000000000007abf7d869e61f461bad9f630ddf9594b05", - "0x00000000000000000000000000000000001111371317a103bc201e8123d6908b", - "0x00000000000000000000000000000055c64593831da4543a3d4b133e864eaf93", - "0x00000000000000000000000000000000000007aad0d55eaa03d5a23d84a35e60", - "0x000000000000000000000000000000165b401eb09f11cdbf56ba958577c91870", - "0x000000000000000000000000000000000024870f45c37a1866cbe92a8e88bbdd", - "0x00000000000000000000000000000022fabd7922e17d5369ed9c82423af1e455", - "0x000000000000000000000000000000000006649913c8489e9ddf864cbfba7f06", - "0x00000000000000000000000000000069115033b40ed21b2de75356921ceab9bb", - "0x000000000000000000000000000000000017967decbb04dea0b3c47f6cc805ed", - "0x000000000000000000000000000000b28d6694439fbe07553cdd206c5dfedebb", - "0x00000000000000000000000000000000000b08cdac94cf3e333b9195d9397ebe", - "0x000000000000000000000000000000cbe98014674062efea69339e44ebb83efc", - "0x00000000000000000000000000000000001e2260b0e077ac85ce74aaae4e72ef", - "0x000000000000000000000000000000bd27cf39ab646d638453f2fc0af16ba04b", - "0x00000000000000000000000000000000000473943ee569fdf17acac9c955c46f", - "0x000000000000000000000000000000864b31708b62da3d34b9f7ae5931f9696e", - "0x00000000000000000000000000000000000df5131cd2846d3102e898fa953ea0", - "0x000000000000000000000000000000d199787d243d0e9f7198c7f8993b47f431", - "0x0000000000000000000000000000000000161ef18b1311eebfa3ea1e312d40fc", - "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", - "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", - "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", - "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x0000000000000000000000000000006e4a0bfce0ed1188f9db0a6dd0de01ff56", - "0x000000000000000000000000000000000028ffb06695207e8e7beefe7ddd9bf2", - "0x000000000000000000000000000000c3bd4e37af8f5cb75f1e44ee1ac1a27822", - "0x00000000000000000000000000000000001a0419b42f40069bfbfb08563363e5", - "0x0000000000000000000000000000006eed465622852dce8a0702c5327cff0583", - "0x000000000000000000000000000000000022b0941f412859d1cc37a757ca4375", - "0x0000000000000000000000000000008bef872c634b8c03bfe7ff37c00a727192", - "0x000000000000000000000000000000000004906c8767a040a562b166a360c43b", - "0x0000000000000000000000000000002196aef3cb99415b3ac5297aac8f112fc6", - "0x0000000000000000000000000000000000202bc7de55cc5837eb14b1c9170f8b", - "0x000000000000000000000000000000bdf27b518418573439ed9eae4c5e5fb565", - "0x000000000000000000000000000000000017b3d9bbe6a673b931642f99c5da31", - "0x000000000000000000000000000000f02ba591cd0b41bb042d8e128595192f02", - "0x00000000000000000000000000000000000e91c21c980b16cf781f41a63337b6", - "0x000000000000000000000000000000df236435bb93d1ba03853ec32ce9bac516", - "0x00000000000000000000000000000000000c79c6f2ebdbb8e9a9ced4fe147b70", - "0x0000000000000000000000000000003fffb3aa510e7f700cf1014e5872d9c836", - "0x00000000000000000000000000000000002a8a152385a9322608448c3b903a25", - "0x000000000000000000000000000000e0e29574c018f3c6738e2e39d4c5add9a0", - "0x00000000000000000000000000000000000fc61b53a775b4a4abe28883bd4cae", - "0x00000000000000000000000000000015ad8f2e516ea41308c308441bd42c61e8", - "0x00000000000000000000000000000000002ae1b82b97d47244a5cbf6785de890", - "0x000000000000000000000000000000c903532912619760836806241aafc8d682", - "0x00000000000000000000000000000000000ad9c58de8e6372d34bc7aac8d1aca", - "0x0000000000000000000000000000008fa9fb6ea15481186d7cd1fc51794441c9", - "0x000000000000000000000000000000000011ecbb05712b264440c324636f313a", - "0x000000000000000000000000000000f56e21c6f0aaefba2220f3a94f80dab6ce", - "0x00000000000000000000000000000000000a6f225feab651d61030c107381417", - "0x0000000000000000000000000000006367da8ecf84e7656d58a4cf7cc1ef2a74", - "0x00000000000000000000000000000000002856f12f04dfa0785028992bc70c8a", - "0x000000000000000000000000000000540359f38ff410089ec6db690c67f8c0a6", - "0x00000000000000000000000000000000002f7ebc5d4a3f260e4a7008711317cd", - "0x0000000000000000000000000000002b55a45f77effa85ca159aaf39ada36b48", - "0x00000000000000000000000000000000001977d307b0175c7c38a065098ee4f0", - "0x00000000000000000000000000000065d17036201631ee10ae596434d01e5faf", - "0x000000000000000000000000000000000028a0ca170089439ba99c006abb5337", - "0x00000000000000000000000000000061b4a81da9a47d25c6a023ce9989052d14", - "0x000000000000000000000000000000000024f0d3b3ea4a55b1ef68ef0706d74d", - "0x0000000000000000000000000000001e9474df0627017ae3a6588c6675e5d37c", - "0x00000000000000000000000000000000000f9309e016418c2988a76cb9a7e6d0", - "0x0000000000000000000000000000005aabd337c2b20b92b5cd9f68fc113fa8fc", - "0x0000000000000000000000000000000000267e283433e6948f6e830121cf07d6", - "0x000000000000000000000000000000e63c28dcb1403d1abd520e3be26f5ea912", - "0x00000000000000000000000000000000000b8e7e8a4f0ee43c9adb3118d1c77c", - "0x00000000000000000000000000000001cb5edebf7fec67758257f420eb739626", - "0x00000000000000000000000000000000002ac6f62034a546864c00f263827917", - "0x0000000000000000000000000000006ffb02c7e19870982b9368ed26a1a90e5b", - "0x000000000000000000000000000000000021d8e1392945c72edde14af5a71989", - "0x000000000000000000000000000000035fe29e7aa320fcacba3b59ca25bc6419", - "0x000000000000000000000000000000000007f147299102f19d56530c50361528", - "0x000000000000000000000000000000e5be284aab52d0591e1613d5674ab90345", - "0x0000000000000000000000000000000000121e8ab82e001622ed0bacd52bbe03", - "0x00000000000000000000000000000003fa9212b7d0d61e9db75b0d68d8b35153", - "0x00000000000000000000000000000000000fb55f91f49661936a9e62dd35a4ce", - "0x00000000000000000000000000000030c134112f5d817a22a316654112fd7714", - "0x00000000000000000000000000000000000a528aa7ced2566011573552cf302e", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000003b87ae780740d3d14ff8f9a547b2926c1b", - "0x00000000000000000000000000000000001cbcc9a266eec40328a8057d238ebd", - "0x0000000000000000000000000000003f6ec85bee0641c92db9ca4fcc5fa3c24a", - "0x00000000000000000000000000000000002f189078dffab22dd8076b731348c8", - "0x0000000000000000000000000000001fad48d68c46c8ce6bd9b67aa6e588bbe0", - "0x00000000000000000000000000000000002fcda688d3b990ca6451a5841e39c1", - "0x000000000000000000000000000000f44fc69aa2dcf70ea4a66b7a9b23c9ab95", - "0x0000000000000000000000000000000000016f201ae57c6fd54a72dba17e156d", - "0x0000000000000000000000000000007b1d6e61b0d5254c9fba726ae7ae9cc66f", - "0x000000000000000000000000000000000002f7da015e525c659a66da56ae616b", - "0x0000000000000000000000000000004f7b93f9c23397a77423f2d327b024943e", - "0x00000000000000000000000000000000001d4011b86d37adeccdf00f76b47447", - "0x0000000000000000000000000000004a4deb709a4b4c26e852e64bf9f8e3d854", - "0x00000000000000000000000000000000002fdd2702a68fda431a1aae6bb8a36a", - "0x0000000000000000000000000000005bc0bd35cd7f4765aadf5249b6d0a58b74", - "0x00000000000000000000000000000000000d439321d69f2e8851f3a88e18f6cf" -] - hash = "0x269f5cc6356c1bfd4868c38cebcc39f9edcae4cb0f5b72ae04bd23bed6d25ddb" - [[inputs.previous_rollups]] proof = [ "0x0000000000000000000000000000000000000000000000000000000000000001", @@ -1097,64 +555,64 @@ new_archive_sibling_path = [ ] [inputs.previous_rollups.public_inputs] - num_txs = "0x0000000000000000000000000000000000000000000000000000000000000002" - out_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" - accumulated_fees = "0x0000000000000000000000000000000000000000000000000000e0c2c3b9a200" - accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000011752b" + num_txs = "0x0000000000000000000000000000000000000000000000000000000000000001" + out_hash = "0x006bd7618b0cf7b40e3f107022eee2d411bcc5850fbb774dacc46a15957659c4" + accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" + accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0" [inputs.previous_rollups.public_inputs.constants] - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - protocol_contracts_hash = "0x080e3881bdd4a4e78d52691e5543b50cf820f51baf52af42d7b58c9e15f96ec7" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" + vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants.last_archive] - root = "0x02b768bc715afcefe7acc2a4394dc1ec3d36e9051f52662c42c795597ad03956" - next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000d" + root = "0x0fb2945d3438d906d88a216364dbfe9760e96001343468610e01d18182d493d0" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [inputs.previous_rollups.public_inputs.constants.l1_to_l2_tree_snapshot] - root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000002c00" + root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.constants.global_variables] - chain_id = "0x0000000000000000000000000000000000000000000000000000000000007a69" - version = "0x000000000000000000000000000000000000000000000000000000005fe47cc3" - block_number = "0x000000000000000000000000000000000000000000000000000000000000000d" - slot_number = "0x000000000000000000000000000000000000000000000000000000000000004b" - timestamp = "0x000000000000000000000000000000000000000000000000000000006a4d2351" + chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + version = "0x0000000000000000000000000000000000000000000000000000000000000000" + block_number = "0x0000000000000000000000000000000000000000000000000000000000000001" + slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f" + timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186" [inputs.previous_rollups.public_inputs.constants.global_variables.coinbase] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants.global_variables.fee_recipient] inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants.global_variables.gas_fees] fee_per_da_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" - fee_per_l2_gas = "0x000000000000000000000000000000000000000000000000000000000cdfe600" + fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.start_tree_snapshots.note_hash_tree] -root = "0x0298ee00030f8d6a3ffea366a5874f37b247e09fcd4551957c2412304739f886" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000240" +root = "0x2590f2aab19dd791700b4a43d3f52bb88ef2409a3731da8e848663559202e4c6" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.start_tree_snapshots.nullifier_tree] -root = "0x2c7cf128d73c690cf7271c4879cec3ace4cac3228f5e03ea928e45a6f3722823" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000002c0" +root = "0x18935581a8ed73d08ffd00386fba55ba6c89f3ab848a76b8fedfa9034cee0454" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.start_tree_snapshots.public_data_tree] -root = "0x2c9dae5a1ef562cdfa66256c803675f421e47ccd4ffd869a29aaddba9e1626a9" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000008b" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.end_tree_snapshots.note_hash_tree] -root = "0x2ecc66f66ba34cbad2712824ccf19b8be619d1ed5d9a2941015091070f0c3bae" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000002c0" +root = "0x01612d24a146efc2df9d815a2f733c17486304424577ffb4232fe4cb0c94e1e7" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000040" [inputs.previous_rollups.public_inputs.end_tree_snapshots.nullifier_tree] -root = "0x14a1f4a7aad9307a23a0ee3113720baeaea791b0536342955f020528e154c6f4" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000340" +root = "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" [inputs.previous_rollups.public_inputs.end_tree_snapshots.public_data_tree] -root = "0x26abb36f6187a9d47bcdda82cc551f41e8596cc04bdc23ac11e4f7289147890c" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000008b" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.start_sponge_blob] num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -1175,84 +633,84 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 squeeze_mode = false [inputs.previous_rollups.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000045" + num_absorbed_fields = "0x00000000000000000000000000000000000000000000000000000000000004cd" [inputs.previous_rollups.public_inputs.end_sponge_blob.sponge] cache = [ - "0x1969a000ba533c2645eb9cea782dbb88f2ed154022b89045c5fba48927e9809a", - "0x2021e773cd9ca18af4f0f0901e25af18f03595de778f302aacfca09d6f6d641c", - "0x2506d48ea4ed2e11a5f4753f87c9a3970477bd31fcacd90bd33b10c2fd7005bd" + "0x00000000000000000000000000000000000000000000000000000000b7d1b44d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44c" ] state = [ - "0x2ea4469ea0669f8f5e980b18d51db0273c0c90e9ec79b8fe28ec1df5e6f8b601", - "0x192e404a9861f10ab23706910d050c568156471a904335368a357fd8582fd8c3", - "0x069f5d0c6f8417c0f0bdb02336db790eb741f768f31ca271e680322755ee4789", - "0x2b382f16e9441dbead7b83a912778cdc3a9042e6ba6af3d254fa612ed341e7c3" + "0x04aaabffb7f35f45dea8e9b68dd48ee04d95e0edd37d79f6f21dbe83f838f018", + "0x258263cc3cf0e87edfb02817e9f7d9dbc1e826b2b3e5b473bc4661e683c698b0", + "0x0d2302e54e05898b7b0659dc607042b33f5d94d6cfaff90d6464952675d81ecc", + "0x272a09845b81d4c6da506c4c7ae326ff16683d03d128a319ed2457249ee1f191" ] - cache_size = "0x0000000000000000000000000000000000000000000000000000000000000003" + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" squeeze_mode = false [inputs.previous_rollups.vk_data] - leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000009" + leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000007" sibling_path = [ - "0x1e73559df90b9ac652f39d057651493cf969d69cefd6a5ab110845f928273371", - "0x0f5051c9544348ed76ea21f6edbd6e24dcb243dba2f146d947505e6e88c20322", - "0x0a2818ba5dd5624d91f012822293d4135b8958ec1d8ab6cf952ee3de138bb8c4", - "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd", - "0x2a17b9f268be22deec2941ce8de06f485f2d164710a5177d262a4ae86b7c351f", + "0x1fc39d0a428c8536dbca551ea79848acf67d89d090fd8c643c7d90f2e8f32340", + "0x12ce5a49a1ceca53ada7bee003f929bbd65abaa74e8072a81f304c2c96c44e31", + "0x2dd71474f7775d87b6c2986ace5f654686583f0970d7400b1ccf8096dad131b5", + "0x0aca02f69b05a42958d30ced7da19a9e135e0c83b75e72ae5f7e2bec714a418f", + "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d", "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" + "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd" ] [inputs.previous_rollups.vk_data.vk] key = [ - "0x0000000000000000000000000000000000000000000000000000000000000015", + "0x0000000000000000000000000000000000000000000000000000000000000016", "0x0000000000000000000000000000000000000000000000000000000000000042", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x0000000000000000000000000000009c72edd2a247b98baee92d045e2e84cf39", - "0x000000000000000000000000000000000006f941fb29caf0fc1129d5b66480c3", - "0x0000000000000000000000000000000a95b0bf6f7d7b6636cfcf9d8aaffa758d", - "0x00000000000000000000000000000000001177d4ef4832d1e422fcb37067d50a", - "0x000000000000000000000000000000a2ca740b8e49052339fd574112d6932bb8", - "0x000000000000000000000000000000000030035f9db88b6837c7ea5bc44d96a4", - "0x0000000000000000000000000000006b49d4a6355cd8ef0ec5a00afafe0b2931", - "0x00000000000000000000000000000000000352522b8b5fd308113352ce4a8a80", - "0x000000000000000000000000000000c663b248762ead4627089ff3b231523661", - "0x0000000000000000000000000000000000133e833b90020e88c9eee0fda60c7e", - "0x000000000000000000000000000000d5f1cfdf57f47ac91b1a9d0f9cac93f955", - "0x0000000000000000000000000000000000225b8ca01cd09e0532e3205493333f", - "0x00000000000000000000000000000000e0007118055feb60eeb9420c695fe7eb", - "0x000000000000000000000000000000000021793910a5d6080a81f9876608a4ef", - "0x000000000000000000000000000000dda76904c41bc9035d0f7b33b9ee696ace", - "0x00000000000000000000000000000000002bba61344d9d95d75624f09128425e", - "0x000000000000000000000000000000390cb5146d68145a832fc688758da7dd64", - "0x0000000000000000000000000000000000164940b75a6dc9e6bdfd175e265b13", - "0x00000000000000000000000000000004e33bdd084c2836f34631aa6048630741", - "0x0000000000000000000000000000000000100c24a84e54f22c44c4a9a38e509a", - "0x0000000000000000000000000000000bd562a8c11d5e415d072167bbafde5fa0", - "0x00000000000000000000000000000000000173659ef499cda7d815e5d80a3774", - "0x000000000000000000000000000000be5b81e39bae1c45ac14a45196648e7f78", - "0x000000000000000000000000000000000014db1cefc28d3435ae0447f1d3cdf5", - "0x0000000000000000000000000000002c54e6c7c66b6dc1c91e9acbae78919983", - "0x00000000000000000000000000000000002265a0363e5b923e1e919725b5f2ab", - "0x00000000000000000000000000000010a9888d4dccc616d59bdc3c1c71b02cc7", - "0x00000000000000000000000000000000000307cb3b8050501351767ba67a7f10", - "0x00000000000000000000000000000005668180c604938afaec3a1ed0083770c3", - "0x00000000000000000000000000000000002022a06cd7f242b2861cf8268e51b9", - "0x0000000000000000000000000000006d2d6e4f136c99893fdcb826d1739ebd37", - "0x000000000000000000000000000000000025f20ff73fe959346ceb7533d0b8fb", + "0x000000000000000000000000000000165ae78531927a33f65caca2e363cc772e", + "0x00000000000000000000000000000000001241b6b86155467b26edfdab7ad6fb", + "0x000000000000000000000000000000b2d0f5b63f894b62d0e60089db80e58d27", + "0x000000000000000000000000000000000008244c501ee23523df6c834feb0e11", + "0x0000000000000000000000000000008672371fd2ce392b4b429418037d12162a", + "0x00000000000000000000000000000000002c7ce75950c33d18096163daf9cab6", + "0x000000000000000000000000000000d87658c101442505855988d5a754acdd88", + "0x0000000000000000000000000000000000137ad22d525a7eff2a2109fcdcae7a", + "0x0000000000000000000000000000006d12443f95a71b142723a798780c49adbd", + "0x000000000000000000000000000000000004e32eeb2532de9b992573f60e45dd", + "0x000000000000000000000000000000df1cbb627e3caab74cabc8712ac00362e9", + "0x000000000000000000000000000000000002e2f623a0fc048dcc89df75393191", + "0x0000000000000000000000000000000b53b2e19c6b1e9cd32e3cf643c416a59d", + "0x000000000000000000000000000000000020bf4d595cc2a10d2be49c507e7e96", + "0x000000000000000000000000000000a86601635b08eeb4993a1cf4033bf9d227", + "0x00000000000000000000000000000000001024c89eaa5827b94a3e6a6f6e2abf", + "0x000000000000000000000000000000f969a6c5173db0b28983bdd5834d3f6474", + "0x00000000000000000000000000000000001ef6a1853c5a97d42e27f8f509574e", + "0x000000000000000000000000000000c1e8d3777151f0521862bfc28f127f0258", + "0x00000000000000000000000000000000002172f71d7b12ef29e40e35f0eb792e", + "0x000000000000000000000000000000d1cf7d66f4a4f6d8e6dcd87fae8754a47c", + "0x0000000000000000000000000000000000281939574f4672879eb703d4d4de39", + "0x0000000000000000000000000000007c7be15eb86fc3e2098e8d224df92270e9", + "0x0000000000000000000000000000000000067d8f76b31d288f52990d7b851906", + "0x0000000000000000000000000000004e4d9ad79291ec12365024f1d5fee16595", + "0x000000000000000000000000000000000020c38b4a8b779b59231117e040791e", + "0x0000000000000000000000000000006fb68858ec3efdae8d238910eb3d7c1caf", + "0x00000000000000000000000000000000002e13d2da09f5dcceb4c2a40e0771c3", + "0x00000000000000000000000000000005ee27483337e5bd9c68e2d9b8685ea567", + "0x00000000000000000000000000000000002785f7e22fca9657887d9b32a7a423", + "0x0000000000000000000000000000005691107b72691b16467cd087d930a639e9", + "0x000000000000000000000000000000000026d6131e96f4a016e33fac0ba06f18", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x000000000000000000000000000000d2ffd9ee52010057d8f5eefa13a76f80c8", - "0x00000000000000000000000000000000002ba1cd0acd1931ea7ab4b5ecc65c1b", - "0x00000000000000000000000000000032ef1588d101fd366998e618306f4b235a", - "0x000000000000000000000000000000000027f476e633f01587475355c44617bd", - "0x000000000000000000000000000000b1795305b34f2f47e00fefef8e3ff03117", - "0x0000000000000000000000000000000000219d203b492d7debf5d8e7df9d2059", - "0x000000000000000000000000000000bfa96395c8478bacb512c36590c5b7b901", - "0x00000000000000000000000000000000001088537efb9ccd4bbaf4c519fb15ef", + "0x000000000000000000000000000000eb965cf70d77f0e2216d04c748f3ab7f5c", + "0x00000000000000000000000000000000001beaa0afc9b05bdf71db514a814532", + "0x0000000000000000000000000000006cd09b0a30f4a93136c9860b93dcdb5bcd", + "0x00000000000000000000000000000000002dd6a841fe0c0bbe07a71c827501f5", + "0x0000000000000000000000000000006f206a04895661d3bd004222a1f8a7fc73", + "0x00000000000000000000000000000000001b12a59a820d3aa543a594a1b9d92f", + "0x0000000000000000000000000000002103559842aca1e08af33bb1f714ebc02a", + "0x00000000000000000000000000000000001b8936a0be628b58af9859c2a851d1", "0x00000000000000000000000000000016c08d152f9dc697daff20714fccf7a5ea", "0x000000000000000000000000000000000021414e160dd06b07bdc4cfc47e4e2c", "0x0000000000000000000000000000002a824f2fcf5190d78d4fc5975ad848a5d1", @@ -1269,60 +727,60 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x000000000000000000000000000000000021a0543de0bc42d6586454ec8b623b", "0x00000000000000000000000000000016bf0724359c9a09ceffdc9371a2d6e5dc", "0x00000000000000000000000000000000002fd4c13c6f5523a7f44b28ce3d342a", - "0x000000000000000000000000000000beda1aad6fd11d15d8da7d061508a3303b", - "0x00000000000000000000000000000000001a1c8dbcc3dd29dc34d7db1705f074", - "0x0000000000000000000000000000005321cb78a890c412428302292c7d82dc59", - "0x00000000000000000000000000000000002dc99f592725128b916102cb937e89", - "0x000000000000000000000000000000a764f06febb6fc246e9a869bf0978c820e", - "0x000000000000000000000000000000000008e3685916162ba4c1bae712cabfa0", - "0x0000000000000000000000000000001df817171be6114e3541f0a6d266e3dc05", - "0x0000000000000000000000000000000000134d97a0490ac8940e9f52236e72fb", - "0x00000000000000000000000000000035c851719afd23ac7449e114787843c22c", - "0x00000000000000000000000000000000001c983a9ff82027746c1aa37fcdcdc3", - "0x000000000000000000000000000000e919f5bc767230c80a03ebae7893e29c96", - "0x000000000000000000000000000000000001f3e2a62a856f0a8a91c2925c5128", - "0x000000000000000000000000000000d471fa1e5b35905eeb0d7276a6d1fc7041", - "0x00000000000000000000000000000000001cd2118b1c14bdfe36b3e62631e1b6", - "0x0000000000000000000000000000006a421ce3850766871be3eead987e61e85c", - "0x00000000000000000000000000000000002412ae02cce15169067e62841fc786", - "0x00000000000000000000000000000011394144e2ca692a4b47d3c512937c64f3", - "0x00000000000000000000000000000000001ca04b5cc6150d41684f2c7ce97452", - "0x000000000000000000000000000000e06ac7361cb7572090ad6f4b921e9edbc6", - "0x0000000000000000000000000000000000002fa895a811f7ef64954c78d0ad81", - "0x00000000000000000000000000000057c547da26c0df0139823c890d14a738d1", - "0x00000000000000000000000000000000002d5d33adf906dfda2d23a113216f81", - "0x000000000000000000000000000000d62f99c9a778404be4543cac8d156181b9", - "0x000000000000000000000000000000000005adb1db772c03ef8afdc5bf59731c", - "0x000000000000000000000000000000fe0629f41367116cfd1dda2341b90a91c0", - "0x000000000000000000000000000000000023d1184f7a974b21dcffa54cc244e2", - "0x0000000000000000000000000000009f5b02b5af8c549e5b4a714f417a26bcb3", - "0x000000000000000000000000000000000005cf6ba732df0c4332889d875fb568", - "0x00000000000000000000000000000014f8688324fbb37f15c506579fe433b5db", - "0x000000000000000000000000000000000011eca7766155663ff7d9aaec915b59", - "0x00000000000000000000000000000064fe789354986ddad3edea44a53d4e7380", - "0x0000000000000000000000000000000000234b3e7b42069697af4b43bc70677b", - "0x000000000000000000000000000000a768bd74ac653325edda6e149d08d76459", - "0x00000000000000000000000000000000000426f6b392743609fa1929ef4a9314", - "0x0000000000000000000000000000008a574a44f7559165e11bd16c5cf21b4e53", - "0x0000000000000000000000000000000000180fbf7d51033ad5da3cf5c16edc2d", - "0x00000000000000000000000000000053053085e1141ba3c94677f97f82ccafc5", - "0x00000000000000000000000000000000001914e8622f808571c83286d354b6b1", - "0x0000000000000000000000000000001a8f745d15bbfba9630f32aadeb7a2dde8", - "0x00000000000000000000000000000000000ee71d332f6aa68899712377dac0e9", - "0x00000000000000000000000000000025f97acf411c17e675f5bf8b34a67744e2", - "0x00000000000000000000000000000000000c464ca4ebe3f8c6ee36f0ef4c1000", - "0x000000000000000000000000000000848ba26aca63eafdf9bd6630b34c2ab8bb", - "0x000000000000000000000000000000000009a8af4fcca5ce396382099608d086", - "0x0000000000000000000000000000003841fbfce4ed2b25cebb016b2a40f1f266", - "0x00000000000000000000000000000000002f14fdee8e81f556947710f623695a", - "0x0000000000000000000000000000008d9fbe089fed6aec54fbaca46b3ff8dc27", - "0x00000000000000000000000000000000001fe11197043854e2bbc7a2913a3562", - "0x000000000000000000000000000000fd984b184c30d3af2350fbfdbdb1c322e2", - "0x000000000000000000000000000000000010794246a9eb75626b0bbd442f5972", - "0x000000000000000000000000000000170e5cec200f14cf4ea0cf1544cd35e2ea", - "0x000000000000000000000000000000000027b493797520c5cdf76fa07ecef3cc" + "0x000000000000000000000000000000c3b10f88e5436be1d5a5a4bb53bff9f86f", + "0x00000000000000000000000000000000000fb0a6d38afc343e251396adad53cf", + "0x00000000000000000000000000000070e87b913346fb9285cbb00737bd57cf7c", + "0x00000000000000000000000000000000002853427de22e10d72478e05c2f3f91", + "0x00000000000000000000000000000052cdddc8f97be52a13f243728d141d2901", + "0x000000000000000000000000000000000015b1139f895206b7e0178e1fc8ba75", + "0x000000000000000000000000000000c13228904b731ff23df21fb368c575405c", + "0x000000000000000000000000000000000025b350c9a547af501a922cd9867da0", + "0x000000000000000000000000000000561589ea814180f093543e48a620ad996c", + "0x00000000000000000000000000000000001fdfc3b1f7112d4ef57921ecde0909", + "0x000000000000000000000000000000099a453cc185766d9aada7cfdb2195d3b0", + "0x00000000000000000000000000000000000e551b1e35be8e8c1a41cbc889702a", + "0x0000000000000000000000000000007ba452ee5e06e123c1fb5cb50dc27007e4", + "0x000000000000000000000000000000000011a0d4e994b8faea474106b96afe46", + "0x000000000000000000000000000000f6ae6d824f37161f26c6515e95acfe76de", + "0x000000000000000000000000000000000029e3bcc9a024ac817c64d605e34fa2", + "0x0000000000000000000000000000002fec07757b3dde0584f30d7df6edc93ec9", + "0x0000000000000000000000000000000000233b6a495366005b18f14a21c37ede", + "0x000000000000000000000000000000d14f4d9f26fea64507ff561fa97d53d9ab", + "0x00000000000000000000000000000000001fb840c0913e222b1da7e26b2b556b", + "0x00000000000000000000000000000005442bad0ec64b17e4b69cc2da15241cdf", + "0x00000000000000000000000000000000002c438af2970405edbb8817c9f71d19", + "0x00000000000000000000000000000088fb3d8a9b6438b9ae1291865d3ab9f50e", + "0x000000000000000000000000000000000007c124e2aa719ddd02048950ed3154", + "0x00000000000000000000000000000034b5893e41adc3972f5ef17616f217463a", + "0x00000000000000000000000000000000002a2e5b545fa30305e181c35d58b00e", + "0x000000000000000000000000000000792d2f9cddf98914ba6ea9c36d9419444e", + "0x000000000000000000000000000000000025b1802368323e36444739ecf3ea7d", + "0x0000000000000000000000000000002d1b5d30f1396ec48b39dec6d2e1d5e9de", + "0x000000000000000000000000000000000026313ea541baf2d94c8ec1df8851be", + "0x000000000000000000000000000000f9b58828fdb3a2c664caf3cd2aa329120e", + "0x000000000000000000000000000000000013a9abade9e01b580cea0d4ec81be2", + "0x000000000000000000000000000000a253a5cc517aeb5355cc507dd13c01649b", + "0x00000000000000000000000000000000000eabf0702aeaf3687ccd37f915963f", + "0x000000000000000000000000000000fa09d1c5b7334edd245ca1c7484751a146", + "0x0000000000000000000000000000000000033a29b33b42df47e072f419ecf1e1", + "0x00000000000000000000000000000068402cb3387e20873c21b5cecbed30ac29", + "0x000000000000000000000000000000000022ea12e03f4fa8be007cfcb236a03d", + "0x000000000000000000000000000000cdddbfa9418b836e50ea09d17406c31e06", + "0x00000000000000000000000000000000002562102f34b4da4a0dc0855981d4ba", + "0x0000000000000000000000000000003fd5d827771206a607d5dffa24cd8c6c4e", + "0x000000000000000000000000000000000022d89961636344dbfb64fc460c980c", + "0x000000000000000000000000000000131a487254d372667a99dc85be24e5cd03", + "0x0000000000000000000000000000000000047b2d5e54f8007f15c8b2fd5c82be", + "0x000000000000000000000000000000976cc58ccb66e097253acb1b3888102f6f", + "0x0000000000000000000000000000000000080c14817c4a9e6eef9dd6ab5d3c16", + "0x000000000000000000000000000000639bb53c2654d493ce5072d8fc2d4954f5", + "0x00000000000000000000000000000000000d85125a9036e1ae1c5a69fb52d3b9", + "0x000000000000000000000000000000f3021896070f4b365fa4fb244174eaa223", + "0x00000000000000000000000000000000000c0f086a0470ef314c720b950ef2ea", + "0x000000000000000000000000000000497578c03ad3935905cf61ca910c7331f5", + "0x0000000000000000000000000000000000002398ed1decdb3cfc47f7457c1174" ] - hash = "0x10b6730f1d1e9c6bf8d7c4b42b64b40d2603e3ae6ddbd464c3d8fcfb9e06e6d4" + hash = "0x080a62f938a5f53f13c6f7f76c406722d810698e6354fed4f4e52ae528e124f5" [[inputs.previous_rollups]] proof = [ @@ -1810,96 +1268,96 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 [inputs.previous_rollups.public_inputs] num_txs = "0x0000000000000000000000000000000000000000000000000000000000000001" - out_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" - accumulated_fees = "0x000000000000000000000000000000000000000000000000000083a35fe8cc00" - accumulated_mana_used = "0x00000000000000000000000000000000000000000000000000000000000a3982" + out_hash = "0x00abb50b8989a7f19fd4526d43e15a1ab5d2a43af413cc8ca91e82a3c8828625" + accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" + accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants] - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - protocol_contracts_hash = "0x080e3881bdd4a4e78d52691e5543b50cf820f51baf52af42d7b58c9e15f96ec7" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" + vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants.last_archive] - root = "0x02b768bc715afcefe7acc2a4394dc1ec3d36e9051f52662c42c795597ad03956" - next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000d" + root = "0x0fb2945d3438d906d88a216364dbfe9760e96001343468610e01d18182d493d0" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [inputs.previous_rollups.public_inputs.constants.l1_to_l2_tree_snapshot] - root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000002c00" + root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.constants.global_variables] - chain_id = "0x0000000000000000000000000000000000000000000000000000000000007a69" - version = "0x000000000000000000000000000000000000000000000000000000005fe47cc3" - block_number = "0x000000000000000000000000000000000000000000000000000000000000000d" - slot_number = "0x000000000000000000000000000000000000000000000000000000000000004b" - timestamp = "0x000000000000000000000000000000000000000000000000000000006a4d2351" + chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + version = "0x0000000000000000000000000000000000000000000000000000000000000000" + block_number = "0x0000000000000000000000000000000000000000000000000000000000000001" + slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f" + timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186" [inputs.previous_rollups.public_inputs.constants.global_variables.coinbase] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants.global_variables.fee_recipient] inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants.global_variables.gas_fees] fee_per_da_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" - fee_per_l2_gas = "0x000000000000000000000000000000000000000000000000000000000cdfe600" + fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.start_tree_snapshots.note_hash_tree] -root = "0x2ecc66f66ba34cbad2712824ccf19b8be619d1ed5d9a2941015091070f0c3bae" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000002c0" +root = "0x01612d24a146efc2df9d815a2f733c17486304424577ffb4232fe4cb0c94e1e7" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000040" [inputs.previous_rollups.public_inputs.start_tree_snapshots.nullifier_tree] -root = "0x14a1f4a7aad9307a23a0ee3113720baeaea791b0536342955f020528e154c6f4" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000340" +root = "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" [inputs.previous_rollups.public_inputs.start_tree_snapshots.public_data_tree] -root = "0x26abb36f6187a9d47bcdda82cc551f41e8596cc04bdc23ac11e4f7289147890c" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000008b" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.end_tree_snapshots.note_hash_tree] -root = "0x2ecc66f66ba34cbad2712824ccf19b8be619d1ed5d9a2941015091070f0c3bae" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000300" +root = "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.end_tree_snapshots.nullifier_tree] -root = "0x05bbdb6d06db6265e0f848b38cdfefd38dda3b667d29aced0513238f2c471264" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000380" +root = "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" [inputs.previous_rollups.public_inputs.end_tree_snapshots.public_data_tree] -root = "0x0041fb3365374b55867227ba19a841bd15da8d512da26a7a5aef327fa1f90ac1" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000008b" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollups.public_inputs.start_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000045" + num_absorbed_fields = "0x00000000000000000000000000000000000000000000000000000000000004cd" [inputs.previous_rollups.public_inputs.start_sponge_blob.sponge] cache = [ - "0x1969a000ba533c2645eb9cea782dbb88f2ed154022b89045c5fba48927e9809a", - "0x2021e773cd9ca18af4f0f0901e25af18f03595de778f302aacfca09d6f6d641c", - "0x2506d48ea4ed2e11a5f4753f87c9a3970477bd31fcacd90bd33b10c2fd7005bd" + "0x00000000000000000000000000000000000000000000000000000000b7d1b44d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44c" ] state = [ - "0x2ea4469ea0669f8f5e980b18d51db0273c0c90e9ec79b8fe28ec1df5e6f8b601", - "0x192e404a9861f10ab23706910d050c568156471a904335368a357fd8582fd8c3", - "0x069f5d0c6f8417c0f0bdb02336db790eb741f768f31ca271e680322755ee4789", - "0x2b382f16e9441dbead7b83a912778cdc3a9042e6ba6af3d254fa612ed341e7c3" + "0x04aaabffb7f35f45dea8e9b68dd48ee04d95e0edd37d79f6f21dbe83f838f018", + "0x258263cc3cf0e87edfb02817e9f7d9dbc1e826b2b3e5b473bc4661e683c698b0", + "0x0d2302e54e05898b7b0659dc607042b33f5d94d6cfaff90d6464952675d81ecc", + "0x272a09845b81d4c6da506c4c7ae326ff16683d03d128a319ed2457249ee1f191" ] - cache_size = "0x0000000000000000000000000000000000000000000000000000000000000003" + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" squeeze_mode = false [inputs.previous_rollups.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x000000000000000000000000000000000000000000000000000000000000004f" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a18" [inputs.previous_rollups.public_inputs.end_sponge_blob.sponge] cache = [ - "0x00000000000000000000000000000000000000000000021e0a6076caaa5a6380", - "0x000000000000000000000000000000000000000000000000000000000000076c", - "0x061ad0f0ed7065820b58cc64574e3bf863d19f7b368dc6d3594bc21208d48f6f" + "0x00000000000000000000000000000000000000000000000000000000b7e5c34e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34d" ] state = [ - "0x0d653cd16026629e1757daeea90a4181cd6d83ce6a6f8cc6311e0e774d3a6d6f", - "0x079fc610149becc66696cd184805c3357dab8e25aee4b276a916312951e81043", - "0x2a3910db26c4807e38ad955db3a385f3b73169e69e9426ea98c761a748276808", - "0x0a8ca0a5c53ae38174655581762e5a1ac0c71d91aa9d1a18a26f51bd27cf2055" + "0x13449344a1e851eb9122ed82ff8fbf021f2e74d74bac4f360f0964c9b5216673", + "0x0d63e47877339d61d174600690b717a4bab73e17a72a9cacef740ad257ad4908", + "0x075e35308cabf2299ccd38d2f5957b30ee819ae7a04dca5cfdbaac40d88c16b8", + "0x2a429fa7f6cfbf48c22feb2f318aaff592c330dc1abc521ec0966efe53cf536d" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" squeeze_mode = false @@ -1908,12 +1366,12 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000008" sibling_path = [ "0x10b6730f1d1e9c6bf8d7c4b42b64b40d2603e3ae6ddbd464c3d8fcfb9e06e6d4", - "0x0f5051c9544348ed76ea21f6edbd6e24dcb243dba2f146d947505e6e88c20322", - "0x0a2818ba5dd5624d91f012822293d4135b8958ec1d8ab6cf952ee3de138bb8c4", + "0x014ffec160e37b6cb713c1a4e6e7058964dde1733e6734520ed72f72fd262919", + "0x196cbe2980734bc5d21b53464a1d00c06dad0febdec75822d79d6933dff40579", "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd", - "0x2a17b9f268be22deec2941ce8de06f485f2d164710a5177d262a4ae86b7c351f", + "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d", "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" + "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd" ] [inputs.previous_rollups.vk_data.vk] @@ -1921,46 +1379,46 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x0000000000000000000000000000000000000000000000000000000000000017", "0x0000000000000000000000000000000000000000000000000000000000000042", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x0000000000000000000000000000009328a328a1d7ae2aa50556292f6544ae6b", - "0x00000000000000000000000000000000000aa5d4c9f48e6dd058c09a1a7fb58d", - "0x000000000000000000000000000000b3eec467daffe4b53b9a863cc25ce83485", - "0x00000000000000000000000000000000002545f85f7cd444bfd463ef9464c127", - "0x000000000000000000000000000000a935dcd8f2f7c2b3d5707ac9e49f751396", - "0x00000000000000000000000000000000000219fb19f7e1f8c2ce2fc9e7792217", - "0x000000000000000000000000000000f2bce39af7c28c3daf14b6cc09d8861849", - "0x0000000000000000000000000000000000011e005fea17bc19ff878ba41e6675", - "0x00000000000000000000000000000047de99203b7ee2fda4db6fa36d746c5ab7", - "0x0000000000000000000000000000000000280ab1316f6e66eac9698dd616935d", - "0x00000000000000000000000000000002a3cecfefbb3065b83cd96a85af8f19e9", - "0x00000000000000000000000000000000002d439a34bc69bbaefa7bc3b8e9d8ca", - "0x000000000000000000000000000000d3ae6bfc445bbd5de744015690d8f93658", - "0x000000000000000000000000000000000016dd6a4d5d69290d171327327b8d6e", - "0x000000000000000000000000000000fbe6c638c966a777499a4d84a702652ea1", - "0x00000000000000000000000000000000001bbba64f59a5fd205ae0e7bf2e69aa", - "0x000000000000000000000000000000dfa788a7bd698c4f83e52100d3d5aed96b", - "0x00000000000000000000000000000000001dbf818746d111c66d328f6fdc0bb1", - "0x000000000000000000000000000000c407fcfd89b1aa059f800cf47b81baba5a", - "0x000000000000000000000000000000000023f10a84b2ee1b5e5e8ceb9dc0fa71", - "0x00000000000000000000000000000045cb054f71e399a8377914b741ac89423d", - "0x000000000000000000000000000000000006b94ebf9dcec725654e630044e4a8", - "0x000000000000000000000000000000e1376352416fe03d8711f23abdbcf5ba60", - "0x00000000000000000000000000000000000a7cc5fbbd3ac3e90bf41415a1fb0a", - "0x00000000000000000000000000000072c67e268debafed7b141bf7ea3170cf64", - "0x00000000000000000000000000000000002c669ba7507217d14a7ed66f47532e", - "0x0000000000000000000000000000008401feacc75ac63d2eb419f97aaec5c77a", - "0x00000000000000000000000000000000001f6986a262963375619443ccaa5c23", - "0x0000000000000000000000000000006fac0e0a31def3bb4c32fe284c99864b9a", - "0x000000000000000000000000000000000007a1ff2509f698f5c7d4374eb9c392", - "0x000000000000000000000000000000fe2bb606f3c248ee28465335c6d32f8fbf", - "0x000000000000000000000000000000000019710c99918555be474cf945692274", + "0x000000000000000000000000000000ed9a7d2d4e3143f585e5d95ca0088bd58c", + "0x000000000000000000000000000000000017f0f4eaca0b57f0254c56d1dcedf7", + "0x000000000000000000000000000000ecccc921a1dbc3116699315b30064501dd", + "0x000000000000000000000000000000000007fad76ddbb6ce8aaca29ac003544c", + "0x000000000000000000000000000000a58f237d5e3447619bd4995b6ab57329f1", + "0x00000000000000000000000000000000002e515ae24d7f583b5f5100e24e3a7d", + "0x000000000000000000000000000000c609b48ceeef44433a6570619898618e60", + "0x000000000000000000000000000000000021d92d4fc9578a1a92cadfd56bac1e", + "0x000000000000000000000000000000b9399d03a2bfe064a77805cd6299a18123", + "0x00000000000000000000000000000000000db15007f51cf45f0d4b5d0c72323f", + "0x0000000000000000000000000000002a813d4b748008a99d0bd98951733eecaa", + "0x00000000000000000000000000000000000006073a97f000f318cf4a87829a35", + "0x000000000000000000000000000000668d42870be7a506027fe80fdc5dd724aa", + "0x0000000000000000000000000000000000280e58b7658c0def5e89405371531f", + "0x000000000000000000000000000000748c0c2a74f8b51f4be7e8609a786d38fb", + "0x000000000000000000000000000000000007c3968791160ba6c2797f72cd485c", + "0x000000000000000000000000000000c047c85668bc7b41958055de15710dffb0", + "0x00000000000000000000000000000000001d09d1eb7e5a7fe0f1ae561fb471a5", + "0x000000000000000000000000000000ad226461b40c2b3ce2ce71eb9b3489b875", + "0x000000000000000000000000000000000028f73ffcd9c4f10b332da3c4202321", + "0x00000000000000000000000000000081bb4666343407adfaf6483652850334e8", + "0x00000000000000000000000000000000001904e26bb7deea88b240fd9f64d6c2", + "0x000000000000000000000000000000046a09098559eb29059aaec545f1b60ab4", + "0x00000000000000000000000000000000002eba2495a17bb6751670d141eba5bc", + "0x0000000000000000000000000000006d4c6812176142054ef8b72fcec9ab1d46", + "0x00000000000000000000000000000000002f17523cebbe0a959a3d3ad4008621", + "0x000000000000000000000000000000fea01dc8a40e8358627aefbdc809f0d16b", + "0x0000000000000000000000000000000000255b95149080440a22c012db52d174", + "0x000000000000000000000000000000b5e6e229f22d5d6130b6940f897bd687ad", + "0x000000000000000000000000000000000002c1d364ecb3f8b13d39b364b9fa17", + "0x0000000000000000000000000000000ace98195a1e28904eeb54e8f1beab8965", + "0x000000000000000000000000000000000021ddb285f5b40df25978b16f38fa55", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x000000000000000000000000000000f8f16d93b4d40b6b37b47c60bb2e15968a", - "0x00000000000000000000000000000000001c66ae5d710e4f03e905237f56896c", - "0x00000000000000000000000000000062e3f05ba19f6d2ee7e046babbd221f7fe", - "0x0000000000000000000000000000000000187b562e03dda0dfccd55b54ad3f3e", + "0x0000000000000000000000000000009723288bf6b623aceeea91e62d1533d690", + "0x0000000000000000000000000000000000015e128393cc29fc38e815d2a2c8bb", + "0x00000000000000000000000000000034f5a0b8bdc854f056ab93f34153f52607", + "0x0000000000000000000000000000000000239dafd7ff901c78c54dac6ef232c4", "0x0000000000000000000000000000006f206a04895661d3bd004222a1f8a7fc73", "0x00000000000000000000000000000000001b12a59a820d3aa543a594a1b9d92f", "0x0000000000000000000000000000002103559842aca1e08af33bb1f714ebc02a", @@ -1981,61 +1439,1091 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x000000000000000000000000000000000021a0543de0bc42d6586454ec8b623b", "0x00000000000000000000000000000016bf0724359c9a09ceffdc9371a2d6e5dc", "0x00000000000000000000000000000000002fd4c13c6f5523a7f44b28ce3d342a", - "0x000000000000000000000000000000900b39279bfc348fe557fb41d1f5d4c8b5", - "0x000000000000000000000000000000000029c825eb725af14205dfdb51bae5de", - "0x0000000000000000000000000000000f0273d62b0aa2ac98edd943d1f4c8f60b", - "0x000000000000000000000000000000000018af8bfa4415bb1e50212aca3d0dce", - "0x000000000000000000000000000000e36aaf472b0fe4d0e2458fe2fd2d3f36a5", - "0x000000000000000000000000000000000024990e730d8de48cc32b305eb892d3", - "0x00000000000000000000000000000046ec4ab852f8095bbde1355df6c9213674", - "0x00000000000000000000000000000000002d9f6208dd41a9391c5f2ff161723b", - "0x000000000000000000000000000000ff206faaa0603e94cf9012d38caf547b71", - "0x00000000000000000000000000000000002b090b6a8885d5642efd8ecb4a9967", - "0x000000000000000000000000000000cde3418169f1900f43c3e6562a3148b92b", - "0x00000000000000000000000000000000001a94d29546f4b269e6deea4d66d87f", - "0x0000000000000000000000000000006974ad4cb642ac7c4817fa36b7b6fa8d6e", - "0x00000000000000000000000000000000002b3a27229b370a8f69a852528a6eb1", - "0x000000000000000000000000000000ee3598685e7189bc323970020b18027714", - "0x000000000000000000000000000000000001ee4d7ef523491e7a7993648f6ee5", - "0x00000000000000000000000000000065af27b4e679703f76baeff7f9f8fde824", - "0x000000000000000000000000000000000013c02a8904a5078fbda6eea9287da5", - "0x000000000000000000000000000000f8054be82ae2c8c42416c32941ff5ff4a0", - "0x000000000000000000000000000000000003fc2699d2a0ff70836b78d9cc6988", - "0x00000000000000000000000000000073b0555261f63360b7869a394c8e7e90ef", - "0x0000000000000000000000000000000000172f74597312d749903182f4fd0e12", - "0x00000000000000000000000000000068c8346993c46672b64d812d6e5f379111", - "0x00000000000000000000000000000000002e1815eca8079dc41036f900b9c788", - "0x0000000000000000000000000000008aaff6db42d06baddf581bd9da6bd2dd5e", - "0x00000000000000000000000000000000000f4a770e94b16e157fc2173e760fd9", - "0x0000000000000000000000000000008971b6d90cc4bce45b75a18b31984bac9f", - "0x0000000000000000000000000000000000243812b999c56279eb2ed4461ddfb5", - "0x0000000000000000000000000000001c197b35b5d02d046ebe0fe0a3e978d15b", - "0x000000000000000000000000000000000014cf7eb2bd158e4a4aa1226de04329", - "0x000000000000000000000000000000fd0cdfc2e8908027336ec0d325f0b3f581", - "0x000000000000000000000000000000000015eea29fa83b4c6b7f71b92bb173d4", - "0x00000000000000000000000000000071c0383bd65ec4578f0a35b617628139ee", - "0x0000000000000000000000000000000000297e66b3248c15286954bde883bbb8", - "0x0000000000000000000000000000000a2c2dec5f0ab63d709ea86670d3ecae6e", - "0x00000000000000000000000000000000002a93ebbca35f379e0535fbce8fc034", - "0x00000000000000000000000000000050e646471d6aa448f5c82ad81bdf9f378d", - "0x00000000000000000000000000000000002dc1b94dc9cb15332fc1862826b86d", - "0x0000000000000000000000000000006ac66c092067851920be2fc0e432413ebf", - "0x000000000000000000000000000000000022ff1934508b1f94313f0a941cfa57", - "0x00000000000000000000000000000091370c3a85062dd23fd6e83c0922a25dd4", - "0x000000000000000000000000000000000003e76557875f4575a3226e83f0a240", - "0x00000000000000000000000000000051758a46a47e0bb3da237577bfca9059a9", - "0x000000000000000000000000000000000004ef694c61d62980e6e04d6aee6826", - "0x000000000000000000000000000000601c96b32be57ad228a169b76ff62df506", - "0x000000000000000000000000000000000024ef565e299f10b00eadc1a1deee3f", - "0x000000000000000000000000000000771bb043879978ce4a2bb82fcfd0be139b", - "0x0000000000000000000000000000000000172c152adac30c20871fab0ec0924b", - "0x0000000000000000000000000000005822c453d08cb7a175254d02adbc691b69", - "0x00000000000000000000000000000000000fda746bab7f21c8fa41a48aea9d61", - "0x0000000000000000000000000000005ac028874e611d55f51c6f227316c3a2b9", - "0x00000000000000000000000000000000001921c1ccbe180174c5e55da318a0c1" + "0x000000000000000000000000000000983b80f553a1f41ea4a613c4272296aa6a", + "0x00000000000000000000000000000000000fad2d11baaeba59740ea2e1e556ab", + "0x0000000000000000000000000000000df8dad25aabadfb2fd689e927f28e9905", + "0x000000000000000000000000000000000006e77d6620186fb40fa775055f6e02", + "0x000000000000000000000000000000ab530a3e0bd1b4d58d3462aaa5248378ec", + "0x00000000000000000000000000000000002128bebd2165991c478744366c2660", + "0x00000000000000000000000000000069959e29b21942c9bc6095c81c52e09e2e", + "0x000000000000000000000000000000000029521e97be7f1262547599981f9dfc", + "0x0000000000000000000000000000004b83cde93267991f2e75cb58d8c62fc648", + "0x000000000000000000000000000000000024bda0836d4ea3d2e8d16bb8b929ff", + "0x00000000000000000000000000000039b6192602f956e962d51c4dbe711e46b9", + "0x00000000000000000000000000000000002b58de5dca4604474742cc42f7a05c", + "0x000000000000000000000000000000dc0d4adfc6bbc96e9863eef8920e82c85c", + "0x00000000000000000000000000000000001c791e40bb700a33ba6343f2d60474", + "0x000000000000000000000000000000213ba680b5b07b331f0153faf572881700", + "0x00000000000000000000000000000000000d2a671fdcd41097454dedb403cf28", + "0x000000000000000000000000000000c40c6f11a42754888c5d0cac2acc5c2e99", + "0x00000000000000000000000000000000001f95faca5af29481f878207f1f3461", + "0x000000000000000000000000000000af74c82994a772d5816d23cad77f507de0", + "0x0000000000000000000000000000000000298a0a94c391ad23bd2714cd83d85b", + "0x000000000000000000000000000000f118536b214a0b173d683952cb179f7308", + "0x00000000000000000000000000000000002048287f58cbf84bd0bdaa216b750b", + "0x0000000000000000000000000000008b7b9a9326671e5fbe01204632efe954cf", + "0x000000000000000000000000000000000000e6e717ef9fe95faf3dc3c94585c0", + "0x0000000000000000000000000000003d73274d5823c057df53030584e69fb7df", + "0x00000000000000000000000000000000001197cce7dac8be65e92fadb47c7e53", + "0x00000000000000000000000000000075d310ff38e2775418a123dcca24d43741", + "0x00000000000000000000000000000000000ca18eff9b17d5e1a103b5c931c576", + "0x00000000000000000000000000000031323a2499d3b128f28b1305246959409a", + "0x00000000000000000000000000000000001dd443e2b9f240a6f8b9b4e29987d3", + "0x00000000000000000000000000000050fea0738e4ca6015860a1370ea49b70a7", + "0x000000000000000000000000000000000017bce74645c162884adc4a6fb7a907", + "0x0000000000000000000000000000007b57ed2a44bfcffc4fc896d15c31ad0d1b", + "0x00000000000000000000000000000000001e4d34edb06ee6ba520d1db5080d9c", + "0x000000000000000000000000000000db1a4b059c0f5fe3e9df6ff8e0d192aca3", + "0x00000000000000000000000000000000001a05c7210c56b6bcd1dc18cff662d9", + "0x000000000000000000000000000000e67e3c5e07fbdd021dcf504db8c63d9b7c", + "0x0000000000000000000000000000000000252935e626c53fe844eb3b48575177", + "0x000000000000000000000000000000c2b7a9a8d8d31df906bb3d90342b9deb2e", + "0x0000000000000000000000000000000000090be4375322103f7233fe4dc9aefe", + "0x000000000000000000000000000000ef6397346da2082caf01b01d285e62e79a", + "0x00000000000000000000000000000000002e6d903371b2347a7cee9a53b3ff86", + "0x000000000000000000000000000000c121fa0e4904211f7d8bd7bed351379d29", + "0x00000000000000000000000000000000002a144c122f68e5b0b50412e6c3341b", + "0x0000000000000000000000000000003cc64d54b35537185ca0399b5e8103b296", + "0x000000000000000000000000000000000004ab8b6bb82552fccc8b2d8b078787", + "0x000000000000000000000000000000d679c88a95d67824fb6cd1be11125f4134", + "0x000000000000000000000000000000000001406dc68a75534a42bc313b9789a6", + "0x0000000000000000000000000000007f458ba267d25862d28eead635c9f44260", + "0x0000000000000000000000000000000000176c2fa161d670836afa9958b8ee4b", + "0x0000000000000000000000000000003ba1cc971819aacf0bcb421bd3aead9f0c", + "0x00000000000000000000000000000000000366f6e08da4f6c87b3393784388b0" +] + hash = "0x2597d0ee94af6c241e63bc541fabe57e418d679cdeb426bc76fe81a01487c4c0" + + [inputs.message_bundle] + messages = [ + "0x00000000000000000000000000000000000000000000000000000000000005dc", + "0x00000000000000000000000000000000000000000000000000000000000005dd", + "0x00000000000000000000000000000000000000000000000000000000000005de", + "0x00000000000000000000000000000000000000000000000000000000000005df", + "0x00000000000000000000000000000000000000000000000000000000000005e0", + "0x00000000000000000000000000000000000000000000000000000000000005e1", + "0x00000000000000000000000000000000000000000000000000000000000005e2", + "0x00000000000000000000000000000000000000000000000000000000000005e3", + "0x00000000000000000000000000000000000000000000000000000000000005e4", + "0x00000000000000000000000000000000000000000000000000000000000005e5", + "0x00000000000000000000000000000000000000000000000000000000000005e6", + "0x00000000000000000000000000000000000000000000000000000000000005e7", + "0x00000000000000000000000000000000000000000000000000000000000005e8", + "0x00000000000000000000000000000000000000000000000000000000000005e9", + "0x00000000000000000000000000000000000000000000000000000000000005ea", + "0x00000000000000000000000000000000000000000000000000000000000005eb", + "0x00000000000000000000000000000000000000000000000000000000000005ec", + "0x00000000000000000000000000000000000000000000000000000000000005ed", + "0x00000000000000000000000000000000000000000000000000000000000005ee", + "0x00000000000000000000000000000000000000000000000000000000000005ef", + "0x00000000000000000000000000000000000000000000000000000000000005f0", + "0x00000000000000000000000000000000000000000000000000000000000005f1", + "0x00000000000000000000000000000000000000000000000000000000000005f2", + "0x00000000000000000000000000000000000000000000000000000000000005f3", + "0x00000000000000000000000000000000000000000000000000000000000005f4", + "0x00000000000000000000000000000000000000000000000000000000000005f5", + "0x00000000000000000000000000000000000000000000000000000000000005f6", + "0x00000000000000000000000000000000000000000000000000000000000005f7", + "0x00000000000000000000000000000000000000000000000000000000000005f8", + "0x00000000000000000000000000000000000000000000000000000000000005f9", + "0x00000000000000000000000000000000000000000000000000000000000005fa", + "0x00000000000000000000000000000000000000000000000000000000000005fb", + "0x00000000000000000000000000000000000000000000000000000000000005fc", + "0x00000000000000000000000000000000000000000000000000000000000005fd", + "0x00000000000000000000000000000000000000000000000000000000000005fe", + "0x00000000000000000000000000000000000000000000000000000000000005ff", + "0x0000000000000000000000000000000000000000000000000000000000000600", + "0x0000000000000000000000000000000000000000000000000000000000000601", + "0x0000000000000000000000000000000000000000000000000000000000000602", + "0x0000000000000000000000000000000000000000000000000000000000000603", + "0x0000000000000000000000000000000000000000000000000000000000000604", + "0x0000000000000000000000000000000000000000000000000000000000000605", + "0x0000000000000000000000000000000000000000000000000000000000000606", + "0x0000000000000000000000000000000000000000000000000000000000000607", + "0x0000000000000000000000000000000000000000000000000000000000000608", + "0x0000000000000000000000000000000000000000000000000000000000000609", + "0x000000000000000000000000000000000000000000000000000000000000060a", + "0x000000000000000000000000000000000000000000000000000000000000060b", + "0x000000000000000000000000000000000000000000000000000000000000060c", + "0x000000000000000000000000000000000000000000000000000000000000060d", + "0x000000000000000000000000000000000000000000000000000000000000060e", + "0x000000000000000000000000000000000000000000000000000000000000060f", + "0x0000000000000000000000000000000000000000000000000000000000000610", + "0x0000000000000000000000000000000000000000000000000000000000000611", + "0x0000000000000000000000000000000000000000000000000000000000000612", + "0x0000000000000000000000000000000000000000000000000000000000000613", + "0x0000000000000000000000000000000000000000000000000000000000000614", + "0x0000000000000000000000000000000000000000000000000000000000000615", + "0x0000000000000000000000000000000000000000000000000000000000000616", + "0x0000000000000000000000000000000000000000000000000000000000000617", + "0x0000000000000000000000000000000000000000000000000000000000000618", + "0x0000000000000000000000000000000000000000000000000000000000000619", + "0x000000000000000000000000000000000000000000000000000000000000061a", + "0x000000000000000000000000000000000000000000000000000000000000061b", + "0x000000000000000000000000000000000000000000000000000000000000061c", + "0x000000000000000000000000000000000000000000000000000000000000061d", + "0x000000000000000000000000000000000000000000000000000000000000061e", + "0x000000000000000000000000000000000000000000000000000000000000061f", + "0x0000000000000000000000000000000000000000000000000000000000000620", + "0x0000000000000000000000000000000000000000000000000000000000000621", + "0x0000000000000000000000000000000000000000000000000000000000000622", + "0x0000000000000000000000000000000000000000000000000000000000000623", + "0x0000000000000000000000000000000000000000000000000000000000000624", + "0x0000000000000000000000000000000000000000000000000000000000000625", + "0x0000000000000000000000000000000000000000000000000000000000000626", + "0x0000000000000000000000000000000000000000000000000000000000000627", + "0x0000000000000000000000000000000000000000000000000000000000000628", + "0x0000000000000000000000000000000000000000000000000000000000000629", + "0x000000000000000000000000000000000000000000000000000000000000062a", + "0x000000000000000000000000000000000000000000000000000000000000062b", + "0x000000000000000000000000000000000000000000000000000000000000062c", + "0x000000000000000000000000000000000000000000000000000000000000062d", + "0x000000000000000000000000000000000000000000000000000000000000062e", + "0x000000000000000000000000000000000000000000000000000000000000062f", + "0x0000000000000000000000000000000000000000000000000000000000000630", + "0x0000000000000000000000000000000000000000000000000000000000000631", + "0x0000000000000000000000000000000000000000000000000000000000000632", + "0x0000000000000000000000000000000000000000000000000000000000000633", + "0x0000000000000000000000000000000000000000000000000000000000000634", + "0x0000000000000000000000000000000000000000000000000000000000000635", + "0x0000000000000000000000000000000000000000000000000000000000000636", + "0x0000000000000000000000000000000000000000000000000000000000000637", + "0x0000000000000000000000000000000000000000000000000000000000000638", + "0x0000000000000000000000000000000000000000000000000000000000000639", + "0x000000000000000000000000000000000000000000000000000000000000063a", + "0x000000000000000000000000000000000000000000000000000000000000063b", + "0x000000000000000000000000000000000000000000000000000000000000063c", + "0x000000000000000000000000000000000000000000000000000000000000063d", + "0x000000000000000000000000000000000000000000000000000000000000063e", + "0x000000000000000000000000000000000000000000000000000000000000063f", + "0x0000000000000000000000000000000000000000000000000000000000000640", + "0x0000000000000000000000000000000000000000000000000000000000000641", + "0x0000000000000000000000000000000000000000000000000000000000000642", + "0x0000000000000000000000000000000000000000000000000000000000000643", + "0x0000000000000000000000000000000000000000000000000000000000000644", + "0x0000000000000000000000000000000000000000000000000000000000000645", + "0x0000000000000000000000000000000000000000000000000000000000000646", + "0x0000000000000000000000000000000000000000000000000000000000000647", + "0x0000000000000000000000000000000000000000000000000000000000000648", + "0x0000000000000000000000000000000000000000000000000000000000000649", + "0x000000000000000000000000000000000000000000000000000000000000064a", + "0x000000000000000000000000000000000000000000000000000000000000064b", + "0x000000000000000000000000000000000000000000000000000000000000064c", + "0x000000000000000000000000000000000000000000000000000000000000064d", + "0x000000000000000000000000000000000000000000000000000000000000064e", + "0x000000000000000000000000000000000000000000000000000000000000064f", + "0x0000000000000000000000000000000000000000000000000000000000000650", + "0x0000000000000000000000000000000000000000000000000000000000000651", + "0x0000000000000000000000000000000000000000000000000000000000000652", + "0x0000000000000000000000000000000000000000000000000000000000000653", + "0x0000000000000000000000000000000000000000000000000000000000000654", + "0x0000000000000000000000000000000000000000000000000000000000000655", + "0x0000000000000000000000000000000000000000000000000000000000000656", + "0x0000000000000000000000000000000000000000000000000000000000000657", + "0x0000000000000000000000000000000000000000000000000000000000000658", + "0x0000000000000000000000000000000000000000000000000000000000000659", + "0x000000000000000000000000000000000000000000000000000000000000065a", + "0x000000000000000000000000000000000000000000000000000000000000065b", + "0x000000000000000000000000000000000000000000000000000000000000065c", + "0x000000000000000000000000000000000000000000000000000000000000065d", + "0x000000000000000000000000000000000000000000000000000000000000065e", + "0x000000000000000000000000000000000000000000000000000000000000065f", + "0x0000000000000000000000000000000000000000000000000000000000000660", + "0x0000000000000000000000000000000000000000000000000000000000000661", + "0x0000000000000000000000000000000000000000000000000000000000000662", + "0x0000000000000000000000000000000000000000000000000000000000000663", + "0x0000000000000000000000000000000000000000000000000000000000000664", + "0x0000000000000000000000000000000000000000000000000000000000000665", + "0x0000000000000000000000000000000000000000000000000000000000000666", + "0x0000000000000000000000000000000000000000000000000000000000000667", + "0x0000000000000000000000000000000000000000000000000000000000000668", + "0x0000000000000000000000000000000000000000000000000000000000000669", + "0x000000000000000000000000000000000000000000000000000000000000066a", + "0x000000000000000000000000000000000000000000000000000000000000066b", + "0x000000000000000000000000000000000000000000000000000000000000066c", + "0x000000000000000000000000000000000000000000000000000000000000066d", + "0x000000000000000000000000000000000000000000000000000000000000066e", + "0x000000000000000000000000000000000000000000000000000000000000066f", + "0x0000000000000000000000000000000000000000000000000000000000000670", + "0x0000000000000000000000000000000000000000000000000000000000000671", + "0x0000000000000000000000000000000000000000000000000000000000000672", + "0x0000000000000000000000000000000000000000000000000000000000000673", + "0x0000000000000000000000000000000000000000000000000000000000000674", + "0x0000000000000000000000000000000000000000000000000000000000000675", + "0x0000000000000000000000000000000000000000000000000000000000000676", + "0x0000000000000000000000000000000000000000000000000000000000000677", + "0x0000000000000000000000000000000000000000000000000000000000000678", + "0x0000000000000000000000000000000000000000000000000000000000000679", + "0x000000000000000000000000000000000000000000000000000000000000067a", + "0x000000000000000000000000000000000000000000000000000000000000067b", + "0x000000000000000000000000000000000000000000000000000000000000067c", + "0x000000000000000000000000000000000000000000000000000000000000067d", + "0x000000000000000000000000000000000000000000000000000000000000067e", + "0x000000000000000000000000000000000000000000000000000000000000067f", + "0x0000000000000000000000000000000000000000000000000000000000000680", + "0x0000000000000000000000000000000000000000000000000000000000000681", + "0x0000000000000000000000000000000000000000000000000000000000000682", + "0x0000000000000000000000000000000000000000000000000000000000000683", + "0x0000000000000000000000000000000000000000000000000000000000000684", + "0x0000000000000000000000000000000000000000000000000000000000000685", + "0x0000000000000000000000000000000000000000000000000000000000000686", + "0x0000000000000000000000000000000000000000000000000000000000000687", + "0x0000000000000000000000000000000000000000000000000000000000000688", + "0x0000000000000000000000000000000000000000000000000000000000000689", + "0x000000000000000000000000000000000000000000000000000000000000068a", + "0x000000000000000000000000000000000000000000000000000000000000068b", + "0x000000000000000000000000000000000000000000000000000000000000068c", + "0x000000000000000000000000000000000000000000000000000000000000068d", + "0x000000000000000000000000000000000000000000000000000000000000068e", + "0x000000000000000000000000000000000000000000000000000000000000068f", + "0x0000000000000000000000000000000000000000000000000000000000000690", + "0x0000000000000000000000000000000000000000000000000000000000000691", + "0x0000000000000000000000000000000000000000000000000000000000000692", + "0x0000000000000000000000000000000000000000000000000000000000000693", + "0x0000000000000000000000000000000000000000000000000000000000000694", + "0x0000000000000000000000000000000000000000000000000000000000000695", + "0x0000000000000000000000000000000000000000000000000000000000000696", + "0x0000000000000000000000000000000000000000000000000000000000000697", + "0x0000000000000000000000000000000000000000000000000000000000000698", + "0x0000000000000000000000000000000000000000000000000000000000000699", + "0x000000000000000000000000000000000000000000000000000000000000069a", + "0x000000000000000000000000000000000000000000000000000000000000069b", + "0x000000000000000000000000000000000000000000000000000000000000069c", + "0x000000000000000000000000000000000000000000000000000000000000069d", + "0x000000000000000000000000000000000000000000000000000000000000069e", + "0x000000000000000000000000000000000000000000000000000000000000069f", + "0x00000000000000000000000000000000000000000000000000000000000006a0", + "0x00000000000000000000000000000000000000000000000000000000000006a1", + "0x00000000000000000000000000000000000000000000000000000000000006a2", + "0x00000000000000000000000000000000000000000000000000000000000006a3", + "0x00000000000000000000000000000000000000000000000000000000000006a4", + "0x00000000000000000000000000000000000000000000000000000000000006a5", + "0x00000000000000000000000000000000000000000000000000000000000006a6", + "0x00000000000000000000000000000000000000000000000000000000000006a7", + "0x00000000000000000000000000000000000000000000000000000000000006a8", + "0x00000000000000000000000000000000000000000000000000000000000006a9", + "0x00000000000000000000000000000000000000000000000000000000000006aa", + "0x00000000000000000000000000000000000000000000000000000000000006ab", + "0x00000000000000000000000000000000000000000000000000000000000006ac", + "0x00000000000000000000000000000000000000000000000000000000000006ad", + "0x00000000000000000000000000000000000000000000000000000000000006ae", + "0x00000000000000000000000000000000000000000000000000000000000006af", + "0x00000000000000000000000000000000000000000000000000000000000006b0", + "0x00000000000000000000000000000000000000000000000000000000000006b1", + "0x00000000000000000000000000000000000000000000000000000000000006b2", + "0x00000000000000000000000000000000000000000000000000000000000006b3", + "0x00000000000000000000000000000000000000000000000000000000000006b4", + "0x00000000000000000000000000000000000000000000000000000000000006b5", + "0x00000000000000000000000000000000000000000000000000000000000006b6", + "0x00000000000000000000000000000000000000000000000000000000000006b7", + "0x00000000000000000000000000000000000000000000000000000000000006b8", + "0x00000000000000000000000000000000000000000000000000000000000006b9", + "0x00000000000000000000000000000000000000000000000000000000000006ba", + "0x00000000000000000000000000000000000000000000000000000000000006bb", + "0x00000000000000000000000000000000000000000000000000000000000006bc", + "0x00000000000000000000000000000000000000000000000000000000000006bd", + "0x00000000000000000000000000000000000000000000000000000000000006be", + "0x00000000000000000000000000000000000000000000000000000000000006bf", + "0x00000000000000000000000000000000000000000000000000000000000006c0", + "0x00000000000000000000000000000000000000000000000000000000000006c1", + "0x00000000000000000000000000000000000000000000000000000000000006c2", + "0x00000000000000000000000000000000000000000000000000000000000006c3", + "0x00000000000000000000000000000000000000000000000000000000000006c4", + "0x00000000000000000000000000000000000000000000000000000000000006c5", + "0x00000000000000000000000000000000000000000000000000000000000006c6", + "0x00000000000000000000000000000000000000000000000000000000000006c7", + "0x00000000000000000000000000000000000000000000000000000000000006c8", + "0x00000000000000000000000000000000000000000000000000000000000006c9", + "0x00000000000000000000000000000000000000000000000000000000000006ca", + "0x00000000000000000000000000000000000000000000000000000000000006cb", + "0x00000000000000000000000000000000000000000000000000000000000006cc", + "0x00000000000000000000000000000000000000000000000000000000000006cd", + "0x00000000000000000000000000000000000000000000000000000000000006ce", + "0x00000000000000000000000000000000000000000000000000000000000006cf", + "0x00000000000000000000000000000000000000000000000000000000000006d0", + "0x00000000000000000000000000000000000000000000000000000000000006d1", + "0x00000000000000000000000000000000000000000000000000000000000006d2", + "0x00000000000000000000000000000000000000000000000000000000000006d3", + "0x00000000000000000000000000000000000000000000000000000000000006d4", + "0x00000000000000000000000000000000000000000000000000000000000006d5", + "0x00000000000000000000000000000000000000000000000000000000000006d6", + "0x00000000000000000000000000000000000000000000000000000000000006d7", + "0x00000000000000000000000000000000000000000000000000000000000006d8", + "0x00000000000000000000000000000000000000000000000000000000000006d9", + "0x00000000000000000000000000000000000000000000000000000000000006da", + "0x00000000000000000000000000000000000000000000000000000000000006db", + "0x00000000000000000000000000000000000000000000000000000000000006dc", + "0x00000000000000000000000000000000000000000000000000000000000006dd", + "0x00000000000000000000000000000000000000000000000000000000000006de", + "0x00000000000000000000000000000000000000000000000000000000000006df", + "0x00000000000000000000000000000000000000000000000000000000000006e0", + "0x00000000000000000000000000000000000000000000000000000000000006e1", + "0x00000000000000000000000000000000000000000000000000000000000006e2", + "0x00000000000000000000000000000000000000000000000000000000000006e3", + "0x00000000000000000000000000000000000000000000000000000000000006e4", + "0x00000000000000000000000000000000000000000000000000000000000006e5", + "0x00000000000000000000000000000000000000000000000000000000000006e6", + "0x00000000000000000000000000000000000000000000000000000000000006e7", + "0x00000000000000000000000000000000000000000000000000000000000006e8", + "0x00000000000000000000000000000000000000000000000000000000000006e9", + "0x00000000000000000000000000000000000000000000000000000000000006ea", + "0x00000000000000000000000000000000000000000000000000000000000006eb", + "0x00000000000000000000000000000000000000000000000000000000000006ec", + "0x00000000000000000000000000000000000000000000000000000000000006ed", + "0x00000000000000000000000000000000000000000000000000000000000006ee", + "0x00000000000000000000000000000000000000000000000000000000000006ef", + "0x00000000000000000000000000000000000000000000000000000000000006f0", + "0x00000000000000000000000000000000000000000000000000000000000006f1", + "0x00000000000000000000000000000000000000000000000000000000000006f2", + "0x00000000000000000000000000000000000000000000000000000000000006f3", + "0x00000000000000000000000000000000000000000000000000000000000006f4", + "0x00000000000000000000000000000000000000000000000000000000000006f5", + "0x00000000000000000000000000000000000000000000000000000000000006f6", + "0x00000000000000000000000000000000000000000000000000000000000006f7", + "0x00000000000000000000000000000000000000000000000000000000000006f8", + "0x00000000000000000000000000000000000000000000000000000000000006f9", + "0x00000000000000000000000000000000000000000000000000000000000006fa", + "0x00000000000000000000000000000000000000000000000000000000000006fb", + "0x00000000000000000000000000000000000000000000000000000000000006fc", + "0x00000000000000000000000000000000000000000000000000000000000006fd", + "0x00000000000000000000000000000000000000000000000000000000000006fe", + "0x00000000000000000000000000000000000000000000000000000000000006ff", + "0x0000000000000000000000000000000000000000000000000000000000000700", + "0x0000000000000000000000000000000000000000000000000000000000000701", + "0x0000000000000000000000000000000000000000000000000000000000000702", + "0x0000000000000000000000000000000000000000000000000000000000000703", + "0x0000000000000000000000000000000000000000000000000000000000000704", + "0x0000000000000000000000000000000000000000000000000000000000000705", + "0x0000000000000000000000000000000000000000000000000000000000000706", + "0x0000000000000000000000000000000000000000000000000000000000000707", + "0x0000000000000000000000000000000000000000000000000000000000000708", + "0x0000000000000000000000000000000000000000000000000000000000000709", + "0x000000000000000000000000000000000000000000000000000000000000070a", + "0x000000000000000000000000000000000000000000000000000000000000070b", + "0x000000000000000000000000000000000000000000000000000000000000070c", + "0x000000000000000000000000000000000000000000000000000000000000070d", + "0x000000000000000000000000000000000000000000000000000000000000070e", + "0x000000000000000000000000000000000000000000000000000000000000070f", + "0x0000000000000000000000000000000000000000000000000000000000000710", + "0x0000000000000000000000000000000000000000000000000000000000000711", + "0x0000000000000000000000000000000000000000000000000000000000000712", + "0x0000000000000000000000000000000000000000000000000000000000000713", + "0x0000000000000000000000000000000000000000000000000000000000000714", + "0x0000000000000000000000000000000000000000000000000000000000000715", + "0x0000000000000000000000000000000000000000000000000000000000000716", + "0x0000000000000000000000000000000000000000000000000000000000000717", + "0x0000000000000000000000000000000000000000000000000000000000000718", + "0x0000000000000000000000000000000000000000000000000000000000000719", + "0x000000000000000000000000000000000000000000000000000000000000071a", + "0x000000000000000000000000000000000000000000000000000000000000071b", + "0x000000000000000000000000000000000000000000000000000000000000071c", + "0x000000000000000000000000000000000000000000000000000000000000071d", + "0x000000000000000000000000000000000000000000000000000000000000071e", + "0x000000000000000000000000000000000000000000000000000000000000071f", + "0x0000000000000000000000000000000000000000000000000000000000000720", + "0x0000000000000000000000000000000000000000000000000000000000000721", + "0x0000000000000000000000000000000000000000000000000000000000000722", + "0x0000000000000000000000000000000000000000000000000000000000000723", + "0x0000000000000000000000000000000000000000000000000000000000000724", + "0x0000000000000000000000000000000000000000000000000000000000000725", + "0x0000000000000000000000000000000000000000000000000000000000000726", + "0x0000000000000000000000000000000000000000000000000000000000000727", + "0x0000000000000000000000000000000000000000000000000000000000000728", + "0x0000000000000000000000000000000000000000000000000000000000000729", + "0x000000000000000000000000000000000000000000000000000000000000072a", + "0x000000000000000000000000000000000000000000000000000000000000072b", + "0x000000000000000000000000000000000000000000000000000000000000072c", + "0x000000000000000000000000000000000000000000000000000000000000072d", + "0x000000000000000000000000000000000000000000000000000000000000072e", + "0x000000000000000000000000000000000000000000000000000000000000072f", + "0x0000000000000000000000000000000000000000000000000000000000000730", + "0x0000000000000000000000000000000000000000000000000000000000000731", + "0x0000000000000000000000000000000000000000000000000000000000000732", + "0x0000000000000000000000000000000000000000000000000000000000000733", + "0x0000000000000000000000000000000000000000000000000000000000000734", + "0x0000000000000000000000000000000000000000000000000000000000000735", + "0x0000000000000000000000000000000000000000000000000000000000000736", + "0x0000000000000000000000000000000000000000000000000000000000000737", + "0x0000000000000000000000000000000000000000000000000000000000000738", + "0x0000000000000000000000000000000000000000000000000000000000000739", + "0x000000000000000000000000000000000000000000000000000000000000073a", + "0x000000000000000000000000000000000000000000000000000000000000073b", + "0x000000000000000000000000000000000000000000000000000000000000073c", + "0x000000000000000000000000000000000000000000000000000000000000073d", + "0x000000000000000000000000000000000000000000000000000000000000073e", + "0x000000000000000000000000000000000000000000000000000000000000073f", + "0x0000000000000000000000000000000000000000000000000000000000000740", + "0x0000000000000000000000000000000000000000000000000000000000000741", + "0x0000000000000000000000000000000000000000000000000000000000000742", + "0x0000000000000000000000000000000000000000000000000000000000000743", + "0x0000000000000000000000000000000000000000000000000000000000000744", + "0x0000000000000000000000000000000000000000000000000000000000000745", + "0x0000000000000000000000000000000000000000000000000000000000000746", + "0x0000000000000000000000000000000000000000000000000000000000000747", + "0x0000000000000000000000000000000000000000000000000000000000000748", + "0x0000000000000000000000000000000000000000000000000000000000000749", + "0x000000000000000000000000000000000000000000000000000000000000074a", + "0x000000000000000000000000000000000000000000000000000000000000074b", + "0x000000000000000000000000000000000000000000000000000000000000074c", + "0x000000000000000000000000000000000000000000000000000000000000074d", + "0x000000000000000000000000000000000000000000000000000000000000074e", + "0x000000000000000000000000000000000000000000000000000000000000074f", + "0x0000000000000000000000000000000000000000000000000000000000000750", + "0x0000000000000000000000000000000000000000000000000000000000000751", + "0x0000000000000000000000000000000000000000000000000000000000000752", + "0x0000000000000000000000000000000000000000000000000000000000000753", + "0x0000000000000000000000000000000000000000000000000000000000000754", + "0x0000000000000000000000000000000000000000000000000000000000000755", + "0x0000000000000000000000000000000000000000000000000000000000000756", + "0x0000000000000000000000000000000000000000000000000000000000000757", + "0x0000000000000000000000000000000000000000000000000000000000000758", + "0x0000000000000000000000000000000000000000000000000000000000000759", + "0x000000000000000000000000000000000000000000000000000000000000075a", + "0x000000000000000000000000000000000000000000000000000000000000075b", + "0x000000000000000000000000000000000000000000000000000000000000075c", + "0x000000000000000000000000000000000000000000000000000000000000075d", + "0x000000000000000000000000000000000000000000000000000000000000075e", + "0x000000000000000000000000000000000000000000000000000000000000075f", + "0x0000000000000000000000000000000000000000000000000000000000000760", + "0x0000000000000000000000000000000000000000000000000000000000000761", + "0x0000000000000000000000000000000000000000000000000000000000000762", + "0x0000000000000000000000000000000000000000000000000000000000000763", + "0x0000000000000000000000000000000000000000000000000000000000000764", + "0x0000000000000000000000000000000000000000000000000000000000000765", + "0x0000000000000000000000000000000000000000000000000000000000000766", + "0x0000000000000000000000000000000000000000000000000000000000000767", + "0x0000000000000000000000000000000000000000000000000000000000000768", + "0x0000000000000000000000000000000000000000000000000000000000000769", + "0x000000000000000000000000000000000000000000000000000000000000076a", + "0x000000000000000000000000000000000000000000000000000000000000076b", + "0x000000000000000000000000000000000000000000000000000000000000076c", + "0x000000000000000000000000000000000000000000000000000000000000076d", + "0x000000000000000000000000000000000000000000000000000000000000076e", + "0x000000000000000000000000000000000000000000000000000000000000076f", + "0x0000000000000000000000000000000000000000000000000000000000000770", + "0x0000000000000000000000000000000000000000000000000000000000000771", + "0x0000000000000000000000000000000000000000000000000000000000000772", + "0x0000000000000000000000000000000000000000000000000000000000000773", + "0x0000000000000000000000000000000000000000000000000000000000000774", + "0x0000000000000000000000000000000000000000000000000000000000000775", + "0x0000000000000000000000000000000000000000000000000000000000000776", + "0x0000000000000000000000000000000000000000000000000000000000000777", + "0x0000000000000000000000000000000000000000000000000000000000000778", + "0x0000000000000000000000000000000000000000000000000000000000000779", + "0x000000000000000000000000000000000000000000000000000000000000077a", + "0x000000000000000000000000000000000000000000000000000000000000077b", + "0x000000000000000000000000000000000000000000000000000000000000077c", + "0x000000000000000000000000000000000000000000000000000000000000077d", + "0x000000000000000000000000000000000000000000000000000000000000077e", + "0x000000000000000000000000000000000000000000000000000000000000077f", + "0x0000000000000000000000000000000000000000000000000000000000000780", + "0x0000000000000000000000000000000000000000000000000000000000000781", + "0x0000000000000000000000000000000000000000000000000000000000000782", + "0x0000000000000000000000000000000000000000000000000000000000000783", + "0x0000000000000000000000000000000000000000000000000000000000000784", + "0x0000000000000000000000000000000000000000000000000000000000000785", + "0x0000000000000000000000000000000000000000000000000000000000000786", + "0x0000000000000000000000000000000000000000000000000000000000000787", + "0x0000000000000000000000000000000000000000000000000000000000000788", + "0x0000000000000000000000000000000000000000000000000000000000000789", + "0x000000000000000000000000000000000000000000000000000000000000078a", + "0x000000000000000000000000000000000000000000000000000000000000078b", + "0x000000000000000000000000000000000000000000000000000000000000078c", + "0x000000000000000000000000000000000000000000000000000000000000078d", + "0x000000000000000000000000000000000000000000000000000000000000078e", + "0x000000000000000000000000000000000000000000000000000000000000078f", + "0x0000000000000000000000000000000000000000000000000000000000000790", + "0x0000000000000000000000000000000000000000000000000000000000000791", + "0x0000000000000000000000000000000000000000000000000000000000000792", + "0x0000000000000000000000000000000000000000000000000000000000000793", + "0x0000000000000000000000000000000000000000000000000000000000000794", + "0x0000000000000000000000000000000000000000000000000000000000000795", + "0x0000000000000000000000000000000000000000000000000000000000000796", + "0x0000000000000000000000000000000000000000000000000000000000000797", + "0x0000000000000000000000000000000000000000000000000000000000000798", + "0x0000000000000000000000000000000000000000000000000000000000000799", + "0x000000000000000000000000000000000000000000000000000000000000079a", + "0x000000000000000000000000000000000000000000000000000000000000079b", + "0x000000000000000000000000000000000000000000000000000000000000079c", + "0x000000000000000000000000000000000000000000000000000000000000079d", + "0x000000000000000000000000000000000000000000000000000000000000079e", + "0x000000000000000000000000000000000000000000000000000000000000079f", + "0x00000000000000000000000000000000000000000000000000000000000007a0", + "0x00000000000000000000000000000000000000000000000000000000000007a1", + "0x00000000000000000000000000000000000000000000000000000000000007a2", + "0x00000000000000000000000000000000000000000000000000000000000007a3", + "0x00000000000000000000000000000000000000000000000000000000000007a4", + "0x00000000000000000000000000000000000000000000000000000000000007a5", + "0x00000000000000000000000000000000000000000000000000000000000007a6", + "0x00000000000000000000000000000000000000000000000000000000000007a7", + "0x00000000000000000000000000000000000000000000000000000000000007a8", + "0x00000000000000000000000000000000000000000000000000000000000007a9", + "0x00000000000000000000000000000000000000000000000000000000000007aa", + "0x00000000000000000000000000000000000000000000000000000000000007ab", + "0x00000000000000000000000000000000000000000000000000000000000007ac", + "0x00000000000000000000000000000000000000000000000000000000000007ad", + "0x00000000000000000000000000000000000000000000000000000000000007ae", + "0x00000000000000000000000000000000000000000000000000000000000007af", + "0x00000000000000000000000000000000000000000000000000000000000007b0", + "0x00000000000000000000000000000000000000000000000000000000000007b1", + "0x00000000000000000000000000000000000000000000000000000000000007b2", + "0x00000000000000000000000000000000000000000000000000000000000007b3", + "0x00000000000000000000000000000000000000000000000000000000000007b4", + "0x00000000000000000000000000000000000000000000000000000000000007b5", + "0x00000000000000000000000000000000000000000000000000000000000007b6", + "0x00000000000000000000000000000000000000000000000000000000000007b7", + "0x00000000000000000000000000000000000000000000000000000000000007b8", + "0x00000000000000000000000000000000000000000000000000000000000007b9", + "0x00000000000000000000000000000000000000000000000000000000000007ba", + "0x00000000000000000000000000000000000000000000000000000000000007bb", + "0x00000000000000000000000000000000000000000000000000000000000007bc", + "0x00000000000000000000000000000000000000000000000000000000000007bd", + "0x00000000000000000000000000000000000000000000000000000000000007be", + "0x00000000000000000000000000000000000000000000000000000000000007bf", + "0x00000000000000000000000000000000000000000000000000000000000007c0", + "0x00000000000000000000000000000000000000000000000000000000000007c1", + "0x00000000000000000000000000000000000000000000000000000000000007c2", + "0x00000000000000000000000000000000000000000000000000000000000007c3", + "0x00000000000000000000000000000000000000000000000000000000000007c4", + "0x00000000000000000000000000000000000000000000000000000000000007c5", + "0x00000000000000000000000000000000000000000000000000000000000007c6", + "0x00000000000000000000000000000000000000000000000000000000000007c7", + "0x00000000000000000000000000000000000000000000000000000000000007c8", + "0x00000000000000000000000000000000000000000000000000000000000007c9", + "0x00000000000000000000000000000000000000000000000000000000000007ca", + "0x00000000000000000000000000000000000000000000000000000000000007cb", + "0x00000000000000000000000000000000000000000000000000000000000007cc", + "0x00000000000000000000000000000000000000000000000000000000000007cd", + "0x00000000000000000000000000000000000000000000000000000000000007ce", + "0x00000000000000000000000000000000000000000000000000000000000007cf", + "0x00000000000000000000000000000000000000000000000000000000000007d0", + "0x00000000000000000000000000000000000000000000000000000000000007d1", + "0x00000000000000000000000000000000000000000000000000000000000007d2", + "0x00000000000000000000000000000000000000000000000000000000000007d3", + "0x00000000000000000000000000000000000000000000000000000000000007d4", + "0x00000000000000000000000000000000000000000000000000000000000007d5", + "0x00000000000000000000000000000000000000000000000000000000000007d6", + "0x00000000000000000000000000000000000000000000000000000000000007d7", + "0x00000000000000000000000000000000000000000000000000000000000007d8", + "0x00000000000000000000000000000000000000000000000000000000000007d9", + "0x00000000000000000000000000000000000000000000000000000000000007da", + "0x00000000000000000000000000000000000000000000000000000000000007db", + "0x00000000000000000000000000000000000000000000000000000000000007dc", + "0x00000000000000000000000000000000000000000000000000000000000007dd", + "0x00000000000000000000000000000000000000000000000000000000000007de", + "0x00000000000000000000000000000000000000000000000000000000000007df", + "0x00000000000000000000000000000000000000000000000000000000000007e0", + "0x00000000000000000000000000000000000000000000000000000000000007e1", + "0x00000000000000000000000000000000000000000000000000000000000007e2", + "0x00000000000000000000000000000000000000000000000000000000000007e3", + "0x00000000000000000000000000000000000000000000000000000000000007e4", + "0x00000000000000000000000000000000000000000000000000000000000007e5", + "0x00000000000000000000000000000000000000000000000000000000000007e6", + "0x00000000000000000000000000000000000000000000000000000000000007e7", + "0x00000000000000000000000000000000000000000000000000000000000007e8", + "0x00000000000000000000000000000000000000000000000000000000000007e9", + "0x00000000000000000000000000000000000000000000000000000000000007ea", + "0x00000000000000000000000000000000000000000000000000000000000007eb", + "0x00000000000000000000000000000000000000000000000000000000000007ec", + "0x00000000000000000000000000000000000000000000000000000000000007ed", + "0x00000000000000000000000000000000000000000000000000000000000007ee", + "0x00000000000000000000000000000000000000000000000000000000000007ef", + "0x00000000000000000000000000000000000000000000000000000000000007f0", + "0x00000000000000000000000000000000000000000000000000000000000007f1", + "0x00000000000000000000000000000000000000000000000000000000000007f2", + "0x00000000000000000000000000000000000000000000000000000000000007f3", + "0x00000000000000000000000000000000000000000000000000000000000007f4", + "0x00000000000000000000000000000000000000000000000000000000000007f5", + "0x00000000000000000000000000000000000000000000000000000000000007f6", + "0x00000000000000000000000000000000000000000000000000000000000007f7", + "0x00000000000000000000000000000000000000000000000000000000000007f8", + "0x00000000000000000000000000000000000000000000000000000000000007f9", + "0x00000000000000000000000000000000000000000000000000000000000007fa", + "0x00000000000000000000000000000000000000000000000000000000000007fb", + "0x00000000000000000000000000000000000000000000000000000000000007fc", + "0x00000000000000000000000000000000000000000000000000000000000007fd", + "0x00000000000000000000000000000000000000000000000000000000000007fe", + "0x00000000000000000000000000000000000000000000000000000000000007ff", + "0x0000000000000000000000000000000000000000000000000000000000000800", + "0x0000000000000000000000000000000000000000000000000000000000000801", + "0x0000000000000000000000000000000000000000000000000000000000000802", + "0x0000000000000000000000000000000000000000000000000000000000000803", + "0x0000000000000000000000000000000000000000000000000000000000000804", + "0x0000000000000000000000000000000000000000000000000000000000000805", + "0x0000000000000000000000000000000000000000000000000000000000000806", + "0x0000000000000000000000000000000000000000000000000000000000000807", + "0x0000000000000000000000000000000000000000000000000000000000000808", + "0x0000000000000000000000000000000000000000000000000000000000000809", + "0x000000000000000000000000000000000000000000000000000000000000080a", + "0x000000000000000000000000000000000000000000000000000000000000080b", + "0x000000000000000000000000000000000000000000000000000000000000080c", + "0x000000000000000000000000000000000000000000000000000000000000080d", + "0x000000000000000000000000000000000000000000000000000000000000080e", + "0x000000000000000000000000000000000000000000000000000000000000080f", + "0x0000000000000000000000000000000000000000000000000000000000000810", + "0x0000000000000000000000000000000000000000000000000000000000000811", + "0x0000000000000000000000000000000000000000000000000000000000000812", + "0x0000000000000000000000000000000000000000000000000000000000000813", + "0x0000000000000000000000000000000000000000000000000000000000000814", + "0x0000000000000000000000000000000000000000000000000000000000000815", + "0x0000000000000000000000000000000000000000000000000000000000000816", + "0x0000000000000000000000000000000000000000000000000000000000000817", + "0x0000000000000000000000000000000000000000000000000000000000000818", + "0x0000000000000000000000000000000000000000000000000000000000000819", + "0x000000000000000000000000000000000000000000000000000000000000081a", + "0x000000000000000000000000000000000000000000000000000000000000081b", + "0x000000000000000000000000000000000000000000000000000000000000081c", + "0x000000000000000000000000000000000000000000000000000000000000081d", + "0x000000000000000000000000000000000000000000000000000000000000081e", + "0x000000000000000000000000000000000000000000000000000000000000081f", + "0x0000000000000000000000000000000000000000000000000000000000000820", + "0x0000000000000000000000000000000000000000000000000000000000000821", + "0x0000000000000000000000000000000000000000000000000000000000000822", + "0x0000000000000000000000000000000000000000000000000000000000000823", + "0x0000000000000000000000000000000000000000000000000000000000000824", + "0x0000000000000000000000000000000000000000000000000000000000000825", + "0x0000000000000000000000000000000000000000000000000000000000000826", + "0x0000000000000000000000000000000000000000000000000000000000000827", + "0x0000000000000000000000000000000000000000000000000000000000000828", + "0x0000000000000000000000000000000000000000000000000000000000000829", + "0x000000000000000000000000000000000000000000000000000000000000082a", + "0x000000000000000000000000000000000000000000000000000000000000082b", + "0x000000000000000000000000000000000000000000000000000000000000082c", + "0x000000000000000000000000000000000000000000000000000000000000082d", + "0x000000000000000000000000000000000000000000000000000000000000082e", + "0x000000000000000000000000000000000000000000000000000000000000082f", + "0x0000000000000000000000000000000000000000000000000000000000000830", + "0x0000000000000000000000000000000000000000000000000000000000000831", + "0x0000000000000000000000000000000000000000000000000000000000000832", + "0x0000000000000000000000000000000000000000000000000000000000000833", + "0x0000000000000000000000000000000000000000000000000000000000000834", + "0x0000000000000000000000000000000000000000000000000000000000000835", + "0x0000000000000000000000000000000000000000000000000000000000000836", + "0x0000000000000000000000000000000000000000000000000000000000000837", + "0x0000000000000000000000000000000000000000000000000000000000000838", + "0x0000000000000000000000000000000000000000000000000000000000000839", + "0x000000000000000000000000000000000000000000000000000000000000083a", + "0x000000000000000000000000000000000000000000000000000000000000083b", + "0x000000000000000000000000000000000000000000000000000000000000083c", + "0x000000000000000000000000000000000000000000000000000000000000083d", + "0x000000000000000000000000000000000000000000000000000000000000083e", + "0x000000000000000000000000000000000000000000000000000000000000083f", + "0x0000000000000000000000000000000000000000000000000000000000000840", + "0x0000000000000000000000000000000000000000000000000000000000000841", + "0x0000000000000000000000000000000000000000000000000000000000000842", + "0x0000000000000000000000000000000000000000000000000000000000000843", + "0x0000000000000000000000000000000000000000000000000000000000000844", + "0x0000000000000000000000000000000000000000000000000000000000000845", + "0x0000000000000000000000000000000000000000000000000000000000000846", + "0x0000000000000000000000000000000000000000000000000000000000000847", + "0x0000000000000000000000000000000000000000000000000000000000000848", + "0x0000000000000000000000000000000000000000000000000000000000000849", + "0x000000000000000000000000000000000000000000000000000000000000084a", + "0x000000000000000000000000000000000000000000000000000000000000084b", + "0x000000000000000000000000000000000000000000000000000000000000084c", + "0x000000000000000000000000000000000000000000000000000000000000084d", + "0x000000000000000000000000000000000000000000000000000000000000084e", + "0x000000000000000000000000000000000000000000000000000000000000084f", + "0x0000000000000000000000000000000000000000000000000000000000000850", + "0x0000000000000000000000000000000000000000000000000000000000000851", + "0x0000000000000000000000000000000000000000000000000000000000000852", + "0x0000000000000000000000000000000000000000000000000000000000000853", + "0x0000000000000000000000000000000000000000000000000000000000000854", + "0x0000000000000000000000000000000000000000000000000000000000000855", + "0x0000000000000000000000000000000000000000000000000000000000000856", + "0x0000000000000000000000000000000000000000000000000000000000000857", + "0x0000000000000000000000000000000000000000000000000000000000000858", + "0x0000000000000000000000000000000000000000000000000000000000000859", + "0x000000000000000000000000000000000000000000000000000000000000085a", + "0x000000000000000000000000000000000000000000000000000000000000085b", + "0x000000000000000000000000000000000000000000000000000000000000085c", + "0x000000000000000000000000000000000000000000000000000000000000085d", + "0x000000000000000000000000000000000000000000000000000000000000085e", + "0x000000000000000000000000000000000000000000000000000000000000085f", + "0x0000000000000000000000000000000000000000000000000000000000000860", + "0x0000000000000000000000000000000000000000000000000000000000000861", + "0x0000000000000000000000000000000000000000000000000000000000000862", + "0x0000000000000000000000000000000000000000000000000000000000000863", + "0x0000000000000000000000000000000000000000000000000000000000000864", + "0x0000000000000000000000000000000000000000000000000000000000000865", + "0x0000000000000000000000000000000000000000000000000000000000000866", + "0x0000000000000000000000000000000000000000000000000000000000000867", + "0x0000000000000000000000000000000000000000000000000000000000000868", + "0x0000000000000000000000000000000000000000000000000000000000000869", + "0x000000000000000000000000000000000000000000000000000000000000086a", + "0x000000000000000000000000000000000000000000000000000000000000086b", + "0x000000000000000000000000000000000000000000000000000000000000086c", + "0x000000000000000000000000000000000000000000000000000000000000086d", + "0x000000000000000000000000000000000000000000000000000000000000086e", + "0x000000000000000000000000000000000000000000000000000000000000086f", + "0x0000000000000000000000000000000000000000000000000000000000000870", + "0x0000000000000000000000000000000000000000000000000000000000000871", + "0x0000000000000000000000000000000000000000000000000000000000000872", + "0x0000000000000000000000000000000000000000000000000000000000000873", + "0x0000000000000000000000000000000000000000000000000000000000000874", + "0x0000000000000000000000000000000000000000000000000000000000000875", + "0x0000000000000000000000000000000000000000000000000000000000000876", + "0x0000000000000000000000000000000000000000000000000000000000000877", + "0x0000000000000000000000000000000000000000000000000000000000000878", + "0x0000000000000000000000000000000000000000000000000000000000000879", + "0x000000000000000000000000000000000000000000000000000000000000087a", + "0x000000000000000000000000000000000000000000000000000000000000087b", + "0x000000000000000000000000000000000000000000000000000000000000087c", + "0x000000000000000000000000000000000000000000000000000000000000087d", + "0x000000000000000000000000000000000000000000000000000000000000087e", + "0x000000000000000000000000000000000000000000000000000000000000087f", + "0x0000000000000000000000000000000000000000000000000000000000000880", + "0x0000000000000000000000000000000000000000000000000000000000000881", + "0x0000000000000000000000000000000000000000000000000000000000000882", + "0x0000000000000000000000000000000000000000000000000000000000000883", + "0x0000000000000000000000000000000000000000000000000000000000000884", + "0x0000000000000000000000000000000000000000000000000000000000000885", + "0x0000000000000000000000000000000000000000000000000000000000000886", + "0x0000000000000000000000000000000000000000000000000000000000000887", + "0x0000000000000000000000000000000000000000000000000000000000000888", + "0x0000000000000000000000000000000000000000000000000000000000000889", + "0x000000000000000000000000000000000000000000000000000000000000088a", + "0x000000000000000000000000000000000000000000000000000000000000088b", + "0x000000000000000000000000000000000000000000000000000000000000088c", + "0x000000000000000000000000000000000000000000000000000000000000088d", + "0x000000000000000000000000000000000000000000000000000000000000088e", + "0x000000000000000000000000000000000000000000000000000000000000088f", + "0x0000000000000000000000000000000000000000000000000000000000000890", + "0x0000000000000000000000000000000000000000000000000000000000000891", + "0x0000000000000000000000000000000000000000000000000000000000000892", + "0x0000000000000000000000000000000000000000000000000000000000000893", + "0x0000000000000000000000000000000000000000000000000000000000000894", + "0x0000000000000000000000000000000000000000000000000000000000000895", + "0x0000000000000000000000000000000000000000000000000000000000000896", + "0x0000000000000000000000000000000000000000000000000000000000000897", + "0x0000000000000000000000000000000000000000000000000000000000000898", + "0x0000000000000000000000000000000000000000000000000000000000000899", + "0x000000000000000000000000000000000000000000000000000000000000089a", + "0x000000000000000000000000000000000000000000000000000000000000089b", + "0x000000000000000000000000000000000000000000000000000000000000089c", + "0x000000000000000000000000000000000000000000000000000000000000089d", + "0x000000000000000000000000000000000000000000000000000000000000089e", + "0x000000000000000000000000000000000000000000000000000000000000089f", + "0x00000000000000000000000000000000000000000000000000000000000008a0", + "0x00000000000000000000000000000000000000000000000000000000000008a1", + "0x00000000000000000000000000000000000000000000000000000000000008a2", + "0x00000000000000000000000000000000000000000000000000000000000008a3", + "0x00000000000000000000000000000000000000000000000000000000000008a4", + "0x00000000000000000000000000000000000000000000000000000000000008a5", + "0x00000000000000000000000000000000000000000000000000000000000008a6", + "0x00000000000000000000000000000000000000000000000000000000000008a7", + "0x00000000000000000000000000000000000000000000000000000000000008a8", + "0x00000000000000000000000000000000000000000000000000000000000008a9", + "0x00000000000000000000000000000000000000000000000000000000000008aa", + "0x00000000000000000000000000000000000000000000000000000000000008ab", + "0x00000000000000000000000000000000000000000000000000000000000008ac", + "0x00000000000000000000000000000000000000000000000000000000000008ad", + "0x00000000000000000000000000000000000000000000000000000000000008ae", + "0x00000000000000000000000000000000000000000000000000000000000008af", + "0x00000000000000000000000000000000000000000000000000000000000008b0", + "0x00000000000000000000000000000000000000000000000000000000000008b1", + "0x00000000000000000000000000000000000000000000000000000000000008b2", + "0x00000000000000000000000000000000000000000000000000000000000008b3", + "0x00000000000000000000000000000000000000000000000000000000000008b4", + "0x00000000000000000000000000000000000000000000000000000000000008b5", + "0x00000000000000000000000000000000000000000000000000000000000008b6", + "0x00000000000000000000000000000000000000000000000000000000000008b7", + "0x00000000000000000000000000000000000000000000000000000000000008b8", + "0x00000000000000000000000000000000000000000000000000000000000008b9", + "0x00000000000000000000000000000000000000000000000000000000000008ba", + "0x00000000000000000000000000000000000000000000000000000000000008bb", + "0x00000000000000000000000000000000000000000000000000000000000008bc", + "0x00000000000000000000000000000000000000000000000000000000000008bd", + "0x00000000000000000000000000000000000000000000000000000000000008be", + "0x00000000000000000000000000000000000000000000000000000000000008bf", + "0x00000000000000000000000000000000000000000000000000000000000008c0", + "0x00000000000000000000000000000000000000000000000000000000000008c1", + "0x00000000000000000000000000000000000000000000000000000000000008c2", + "0x00000000000000000000000000000000000000000000000000000000000008c3", + "0x00000000000000000000000000000000000000000000000000000000000008c4", + "0x00000000000000000000000000000000000000000000000000000000000008c5", + "0x00000000000000000000000000000000000000000000000000000000000008c6", + "0x00000000000000000000000000000000000000000000000000000000000008c7", + "0x00000000000000000000000000000000000000000000000000000000000008c8", + "0x00000000000000000000000000000000000000000000000000000000000008c9", + "0x00000000000000000000000000000000000000000000000000000000000008ca", + "0x00000000000000000000000000000000000000000000000000000000000008cb", + "0x00000000000000000000000000000000000000000000000000000000000008cc", + "0x00000000000000000000000000000000000000000000000000000000000008cd", + "0x00000000000000000000000000000000000000000000000000000000000008ce", + "0x00000000000000000000000000000000000000000000000000000000000008cf", + "0x00000000000000000000000000000000000000000000000000000000000008d0", + "0x00000000000000000000000000000000000000000000000000000000000008d1", + "0x00000000000000000000000000000000000000000000000000000000000008d2", + "0x00000000000000000000000000000000000000000000000000000000000008d3", + "0x00000000000000000000000000000000000000000000000000000000000008d4", + "0x00000000000000000000000000000000000000000000000000000000000008d5", + "0x00000000000000000000000000000000000000000000000000000000000008d6", + "0x00000000000000000000000000000000000000000000000000000000000008d7", + "0x00000000000000000000000000000000000000000000000000000000000008d8", + "0x00000000000000000000000000000000000000000000000000000000000008d9", + "0x00000000000000000000000000000000000000000000000000000000000008da", + "0x00000000000000000000000000000000000000000000000000000000000008db", + "0x00000000000000000000000000000000000000000000000000000000000008dc", + "0x00000000000000000000000000000000000000000000000000000000000008dd", + "0x00000000000000000000000000000000000000000000000000000000000008de", + "0x00000000000000000000000000000000000000000000000000000000000008df", + "0x00000000000000000000000000000000000000000000000000000000000008e0", + "0x00000000000000000000000000000000000000000000000000000000000008e1", + "0x00000000000000000000000000000000000000000000000000000000000008e2", + "0x00000000000000000000000000000000000000000000000000000000000008e3", + "0x00000000000000000000000000000000000000000000000000000000000008e4", + "0x00000000000000000000000000000000000000000000000000000000000008e5", + "0x00000000000000000000000000000000000000000000000000000000000008e6", + "0x00000000000000000000000000000000000000000000000000000000000008e7", + "0x00000000000000000000000000000000000000000000000000000000000008e8", + "0x00000000000000000000000000000000000000000000000000000000000008e9", + "0x00000000000000000000000000000000000000000000000000000000000008ea", + "0x00000000000000000000000000000000000000000000000000000000000008eb", + "0x00000000000000000000000000000000000000000000000000000000000008ec", + "0x00000000000000000000000000000000000000000000000000000000000008ed", + "0x00000000000000000000000000000000000000000000000000000000000008ee", + "0x00000000000000000000000000000000000000000000000000000000000008ef", + "0x00000000000000000000000000000000000000000000000000000000000008f0", + "0x00000000000000000000000000000000000000000000000000000000000008f1", + "0x00000000000000000000000000000000000000000000000000000000000008f2", + "0x00000000000000000000000000000000000000000000000000000000000008f3", + "0x00000000000000000000000000000000000000000000000000000000000008f4", + "0x00000000000000000000000000000000000000000000000000000000000008f5", + "0x00000000000000000000000000000000000000000000000000000000000008f6", + "0x00000000000000000000000000000000000000000000000000000000000008f7", + "0x00000000000000000000000000000000000000000000000000000000000008f8", + "0x00000000000000000000000000000000000000000000000000000000000008f9", + "0x00000000000000000000000000000000000000000000000000000000000008fa", + "0x00000000000000000000000000000000000000000000000000000000000008fb", + "0x00000000000000000000000000000000000000000000000000000000000008fc", + "0x00000000000000000000000000000000000000000000000000000000000008fd", + "0x00000000000000000000000000000000000000000000000000000000000008fe", + "0x00000000000000000000000000000000000000000000000000000000000008ff", + "0x0000000000000000000000000000000000000000000000000000000000000900", + "0x0000000000000000000000000000000000000000000000000000000000000901", + "0x0000000000000000000000000000000000000000000000000000000000000902", + "0x0000000000000000000000000000000000000000000000000000000000000903", + "0x0000000000000000000000000000000000000000000000000000000000000904", + "0x0000000000000000000000000000000000000000000000000000000000000905", + "0x0000000000000000000000000000000000000000000000000000000000000906", + "0x0000000000000000000000000000000000000000000000000000000000000907", + "0x0000000000000000000000000000000000000000000000000000000000000908", + "0x0000000000000000000000000000000000000000000000000000000000000909", + "0x000000000000000000000000000000000000000000000000000000000000090a", + "0x000000000000000000000000000000000000000000000000000000000000090b", + "0x000000000000000000000000000000000000000000000000000000000000090c", + "0x000000000000000000000000000000000000000000000000000000000000090d", + "0x000000000000000000000000000000000000000000000000000000000000090e", + "0x000000000000000000000000000000000000000000000000000000000000090f", + "0x0000000000000000000000000000000000000000000000000000000000000910", + "0x0000000000000000000000000000000000000000000000000000000000000911", + "0x0000000000000000000000000000000000000000000000000000000000000912", + "0x0000000000000000000000000000000000000000000000000000000000000913", + "0x0000000000000000000000000000000000000000000000000000000000000914", + "0x0000000000000000000000000000000000000000000000000000000000000915", + "0x0000000000000000000000000000000000000000000000000000000000000916", + "0x0000000000000000000000000000000000000000000000000000000000000917", + "0x0000000000000000000000000000000000000000000000000000000000000918", + "0x0000000000000000000000000000000000000000000000000000000000000919", + "0x000000000000000000000000000000000000000000000000000000000000091a", + "0x000000000000000000000000000000000000000000000000000000000000091b", + "0x000000000000000000000000000000000000000000000000000000000000091c", + "0x000000000000000000000000000000000000000000000000000000000000091d", + "0x000000000000000000000000000000000000000000000000000000000000091e", + "0x000000000000000000000000000000000000000000000000000000000000091f", + "0x0000000000000000000000000000000000000000000000000000000000000920", + "0x0000000000000000000000000000000000000000000000000000000000000921", + "0x0000000000000000000000000000000000000000000000000000000000000922", + "0x0000000000000000000000000000000000000000000000000000000000000923", + "0x0000000000000000000000000000000000000000000000000000000000000924", + "0x0000000000000000000000000000000000000000000000000000000000000925", + "0x0000000000000000000000000000000000000000000000000000000000000926", + "0x0000000000000000000000000000000000000000000000000000000000000927", + "0x0000000000000000000000000000000000000000000000000000000000000928", + "0x0000000000000000000000000000000000000000000000000000000000000929", + "0x000000000000000000000000000000000000000000000000000000000000092a", + "0x000000000000000000000000000000000000000000000000000000000000092b", + "0x000000000000000000000000000000000000000000000000000000000000092c", + "0x000000000000000000000000000000000000000000000000000000000000092d", + "0x000000000000000000000000000000000000000000000000000000000000092e", + "0x000000000000000000000000000000000000000000000000000000000000092f", + "0x0000000000000000000000000000000000000000000000000000000000000930", + "0x0000000000000000000000000000000000000000000000000000000000000931", + "0x0000000000000000000000000000000000000000000000000000000000000932", + "0x0000000000000000000000000000000000000000000000000000000000000933", + "0x0000000000000000000000000000000000000000000000000000000000000934", + "0x0000000000000000000000000000000000000000000000000000000000000935", + "0x0000000000000000000000000000000000000000000000000000000000000936", + "0x0000000000000000000000000000000000000000000000000000000000000937", + "0x0000000000000000000000000000000000000000000000000000000000000938", + "0x0000000000000000000000000000000000000000000000000000000000000939", + "0x000000000000000000000000000000000000000000000000000000000000093a", + "0x000000000000000000000000000000000000000000000000000000000000093b", + "0x000000000000000000000000000000000000000000000000000000000000093c", + "0x000000000000000000000000000000000000000000000000000000000000093d", + "0x000000000000000000000000000000000000000000000000000000000000093e", + "0x000000000000000000000000000000000000000000000000000000000000093f", + "0x0000000000000000000000000000000000000000000000000000000000000940", + "0x0000000000000000000000000000000000000000000000000000000000000941", + "0x0000000000000000000000000000000000000000000000000000000000000942", + "0x0000000000000000000000000000000000000000000000000000000000000943", + "0x0000000000000000000000000000000000000000000000000000000000000944", + "0x0000000000000000000000000000000000000000000000000000000000000945", + "0x0000000000000000000000000000000000000000000000000000000000000946", + "0x0000000000000000000000000000000000000000000000000000000000000947", + "0x0000000000000000000000000000000000000000000000000000000000000948", + "0x0000000000000000000000000000000000000000000000000000000000000949", + "0x000000000000000000000000000000000000000000000000000000000000094a", + "0x000000000000000000000000000000000000000000000000000000000000094b", + "0x000000000000000000000000000000000000000000000000000000000000094c", + "0x000000000000000000000000000000000000000000000000000000000000094d", + "0x000000000000000000000000000000000000000000000000000000000000094e", + "0x000000000000000000000000000000000000000000000000000000000000094f", + "0x0000000000000000000000000000000000000000000000000000000000000950", + "0x0000000000000000000000000000000000000000000000000000000000000951", + "0x0000000000000000000000000000000000000000000000000000000000000952", + "0x0000000000000000000000000000000000000000000000000000000000000953", + "0x0000000000000000000000000000000000000000000000000000000000000954", + "0x0000000000000000000000000000000000000000000000000000000000000955", + "0x0000000000000000000000000000000000000000000000000000000000000956", + "0x0000000000000000000000000000000000000000000000000000000000000957", + "0x0000000000000000000000000000000000000000000000000000000000000958", + "0x0000000000000000000000000000000000000000000000000000000000000959", + "0x000000000000000000000000000000000000000000000000000000000000095a", + "0x000000000000000000000000000000000000000000000000000000000000095b", + "0x000000000000000000000000000000000000000000000000000000000000095c", + "0x000000000000000000000000000000000000000000000000000000000000095d", + "0x000000000000000000000000000000000000000000000000000000000000095e", + "0x000000000000000000000000000000000000000000000000000000000000095f", + "0x0000000000000000000000000000000000000000000000000000000000000960", + "0x0000000000000000000000000000000000000000000000000000000000000961", + "0x0000000000000000000000000000000000000000000000000000000000000962", + "0x0000000000000000000000000000000000000000000000000000000000000963", + "0x0000000000000000000000000000000000000000000000000000000000000964", + "0x0000000000000000000000000000000000000000000000000000000000000965", + "0x0000000000000000000000000000000000000000000000000000000000000966", + "0x0000000000000000000000000000000000000000000000000000000000000967", + "0x0000000000000000000000000000000000000000000000000000000000000968", + "0x0000000000000000000000000000000000000000000000000000000000000969", + "0x000000000000000000000000000000000000000000000000000000000000096a", + "0x000000000000000000000000000000000000000000000000000000000000096b", + "0x000000000000000000000000000000000000000000000000000000000000096c", + "0x000000000000000000000000000000000000000000000000000000000000096d", + "0x000000000000000000000000000000000000000000000000000000000000096e", + "0x000000000000000000000000000000000000000000000000000000000000096f", + "0x0000000000000000000000000000000000000000000000000000000000000970", + "0x0000000000000000000000000000000000000000000000000000000000000971", + "0x0000000000000000000000000000000000000000000000000000000000000972", + "0x0000000000000000000000000000000000000000000000000000000000000973", + "0x0000000000000000000000000000000000000000000000000000000000000974", + "0x0000000000000000000000000000000000000000000000000000000000000975", + "0x0000000000000000000000000000000000000000000000000000000000000976", + "0x0000000000000000000000000000000000000000000000000000000000000977", + "0x0000000000000000000000000000000000000000000000000000000000000978", + "0x0000000000000000000000000000000000000000000000000000000000000979", + "0x000000000000000000000000000000000000000000000000000000000000097a", + "0x000000000000000000000000000000000000000000000000000000000000097b", + "0x000000000000000000000000000000000000000000000000000000000000097c", + "0x000000000000000000000000000000000000000000000000000000000000097d", + "0x000000000000000000000000000000000000000000000000000000000000097e", + "0x000000000000000000000000000000000000000000000000000000000000097f", + "0x0000000000000000000000000000000000000000000000000000000000000980", + "0x0000000000000000000000000000000000000000000000000000000000000981", + "0x0000000000000000000000000000000000000000000000000000000000000982", + "0x0000000000000000000000000000000000000000000000000000000000000983", + "0x0000000000000000000000000000000000000000000000000000000000000984", + "0x0000000000000000000000000000000000000000000000000000000000000985", + "0x0000000000000000000000000000000000000000000000000000000000000986", + "0x0000000000000000000000000000000000000000000000000000000000000987", + "0x0000000000000000000000000000000000000000000000000000000000000988", + "0x0000000000000000000000000000000000000000000000000000000000000989", + "0x000000000000000000000000000000000000000000000000000000000000098a", + "0x000000000000000000000000000000000000000000000000000000000000098b", + "0x000000000000000000000000000000000000000000000000000000000000098c", + "0x000000000000000000000000000000000000000000000000000000000000098d", + "0x000000000000000000000000000000000000000000000000000000000000098e", + "0x000000000000000000000000000000000000000000000000000000000000098f", + "0x0000000000000000000000000000000000000000000000000000000000000990", + "0x0000000000000000000000000000000000000000000000000000000000000991", + "0x0000000000000000000000000000000000000000000000000000000000000992", + "0x0000000000000000000000000000000000000000000000000000000000000993", + "0x0000000000000000000000000000000000000000000000000000000000000994", + "0x0000000000000000000000000000000000000000000000000000000000000995", + "0x0000000000000000000000000000000000000000000000000000000000000996", + "0x0000000000000000000000000000000000000000000000000000000000000997", + "0x0000000000000000000000000000000000000000000000000000000000000998", + "0x0000000000000000000000000000000000000000000000000000000000000999", + "0x000000000000000000000000000000000000000000000000000000000000099a", + "0x000000000000000000000000000000000000000000000000000000000000099b", + "0x000000000000000000000000000000000000000000000000000000000000099c", + "0x000000000000000000000000000000000000000000000000000000000000099d", + "0x000000000000000000000000000000000000000000000000000000000000099e", + "0x000000000000000000000000000000000000000000000000000000000000099f", + "0x00000000000000000000000000000000000000000000000000000000000009a0", + "0x00000000000000000000000000000000000000000000000000000000000009a1", + "0x00000000000000000000000000000000000000000000000000000000000009a2", + "0x00000000000000000000000000000000000000000000000000000000000009a3", + "0x00000000000000000000000000000000000000000000000000000000000009a4", + "0x00000000000000000000000000000000000000000000000000000000000009a5", + "0x00000000000000000000000000000000000000000000000000000000000009a6", + "0x00000000000000000000000000000000000000000000000000000000000009a7", + "0x00000000000000000000000000000000000000000000000000000000000009a8", + "0x00000000000000000000000000000000000000000000000000000000000009a9", + "0x00000000000000000000000000000000000000000000000000000000000009aa", + "0x00000000000000000000000000000000000000000000000000000000000009ab", + "0x00000000000000000000000000000000000000000000000000000000000009ac", + "0x00000000000000000000000000000000000000000000000000000000000009ad", + "0x00000000000000000000000000000000000000000000000000000000000009ae", + "0x00000000000000000000000000000000000000000000000000000000000009af", + "0x00000000000000000000000000000000000000000000000000000000000009b0", + "0x00000000000000000000000000000000000000000000000000000000000009b1", + "0x00000000000000000000000000000000000000000000000000000000000009b2", + "0x00000000000000000000000000000000000000000000000000000000000009b3", + "0x00000000000000000000000000000000000000000000000000000000000009b4", + "0x00000000000000000000000000000000000000000000000000000000000009b5", + "0x00000000000000000000000000000000000000000000000000000000000009b6", + "0x00000000000000000000000000000000000000000000000000000000000009b7", + "0x00000000000000000000000000000000000000000000000000000000000009b8", + "0x00000000000000000000000000000000000000000000000000000000000009b9", + "0x00000000000000000000000000000000000000000000000000000000000009ba", + "0x00000000000000000000000000000000000000000000000000000000000009bb", + "0x00000000000000000000000000000000000000000000000000000000000009bc", + "0x00000000000000000000000000000000000000000000000000000000000009bd", + "0x00000000000000000000000000000000000000000000000000000000000009be", + "0x00000000000000000000000000000000000000000000000000000000000009bf", + "0x00000000000000000000000000000000000000000000000000000000000009c0", + "0x00000000000000000000000000000000000000000000000000000000000009c1", + "0x00000000000000000000000000000000000000000000000000000000000009c2", + "0x00000000000000000000000000000000000000000000000000000000000009c3", + "0x00000000000000000000000000000000000000000000000000000000000009c4", + "0x00000000000000000000000000000000000000000000000000000000000009c5", + "0x00000000000000000000000000000000000000000000000000000000000009c6", + "0x00000000000000000000000000000000000000000000000000000000000009c7", + "0x00000000000000000000000000000000000000000000000000000000000009c8", + "0x00000000000000000000000000000000000000000000000000000000000009c9", + "0x00000000000000000000000000000000000000000000000000000000000009ca", + "0x00000000000000000000000000000000000000000000000000000000000009cb", + "0x00000000000000000000000000000000000000000000000000000000000009cc", + "0x00000000000000000000000000000000000000000000000000000000000009cd", + "0x00000000000000000000000000000000000000000000000000000000000009ce", + "0x00000000000000000000000000000000000000000000000000000000000009cf", + "0x00000000000000000000000000000000000000000000000000000000000009d0", + "0x00000000000000000000000000000000000000000000000000000000000009d1", + "0x00000000000000000000000000000000000000000000000000000000000009d2", + "0x00000000000000000000000000000000000000000000000000000000000009d3", + "0x00000000000000000000000000000000000000000000000000000000000009d4", + "0x00000000000000000000000000000000000000000000000000000000000009d5", + "0x00000000000000000000000000000000000000000000000000000000000009d6", + "0x00000000000000000000000000000000000000000000000000000000000009d7", + "0x00000000000000000000000000000000000000000000000000000000000009d8", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da", + "0x00000000000000000000000000000000000000000000000000000000000009db" ] - hash = "0x1e73559df90b9ac652f39d057651493cf969d69cefd6a5ab110845f928273371" + num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400" + num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_l1_to_l2] root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000002800" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-msgs-only/Nargo.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-msgs-only/Nargo.toml new file mode 100644 index 000000000000..01ba21dedeb3 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-msgs-only/Nargo.toml @@ -0,0 +1,8 @@ +[package] +name = "rollup_block_root_msgs_only" +type = "bin" +authors = [""] +compiler_version = ">=0.18.0" + +[dependencies] +rollup_lib = { path = "../rollup-lib" } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-msgs-only/src/main.nr b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-msgs-only/src/main.nr new file mode 100644 index 000000000000..6b2a522ff1e7 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-msgs-only/src/main.nr @@ -0,0 +1,7 @@ +use rollup_lib::block_root::{ + block_root_msgs_only_rollup, BlockRollupPublicInputs, BlockRootMsgsOnlyRollupPrivateInputs, +}; + +fn main(inputs: BlockRootMsgsOnlyRollupPrivateInputs) -> pub BlockRollupPublicInputs { + block_root_msgs_only_rollup::execute(inputs) +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx/Prover.toml index 55da03b4c7d9..6ff6bca8bbe4 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root-single-tx/Prover.toml @@ -1,7 +1,45 @@ [inputs] +l1_to_l2_message_frontier_hint = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x2c7fea674d2d40f18ffc3f161020dcd660472023bdc7774ae7cdf7b250153f4d", + "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad", + "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da", + "0x1077e8e59029b12e321c47a8a2a25283e50664b6ca1dd766a83828ddc6a22bb9", + "0x15b7bb46f75a6826da53df52c290eda3ddea8924becad6e9a3c08e4eb9a6f604", + "0x0f092097aaee3e41e55706add0701d0eff7a0c972a909dcbc915a478cbc8f122", + "0x2cf33c7d57e1ff8f3d98aabae3092befa8e92274da5e6d324ba0b8839889d27c", + "0x137e350aaf8bab893d768cb6e14bc5464877833efbb8c7091da9ecc7a96bc7b7", + "0x016505cc51b09b257b8c96b5fb20e90bd9e68416286a904d9f86b805e5a89e13", + "0x04d6e1009a70843f5bad89c59765d09421aad04e3276fc90f2a459565057978a", + "0x093a8215cd7e725a45949f4d6d4faec9d078221f09d26a27d61e4f0bf670a580", + "0x1704545cd66b0aa172d2c355fac161d17d7ea42f0132d24708762b544fa17357", + "0x2db6ed73abe6fc42bde50d4422c3e0c81def268d702b9256b7e67cafbbd0325c", + "0x21868e4f8cdcbcb9754d297edc2a361754517465c469017e784a4347f9eb6644", + "0x1adbb821ee5346b1979da8ddbb58789f5ef90c31ece8f0c543c221a3ef0f0aed", + "0x2058aa06a8e23bc53a625831ce1df1aa8d8f01924ad840607f33805aee179d90", + "0x1002be9f0852a234617c837e49555e328bb19a71fcea0ff34368901cee52c85e", + "0x2b238a0d25b834a061e45d817289ab221d13fd0e4cc7adf72d91d54c280f1aa0", + "0x15fada375c113bd526097e297b422ffb59f54a5451e5b70d4a4b028dc65208d1", + "0x2aad701e57c7069cb4e148d971c0eae9ac7429d7d833c51d87875ead0c5aca3c", + "0x2403f18ba27f090c40c95fc6724d67b4b7d537b967ee15656c79e55284df9d6b", + "0x13404ebc0eed291ffb14cad19114bad8df35bae99793ea99e4dde966cb4e53ad", + "0x006a1008132293c19aafbe7130eda035bd1b90065032894071b1f390f4946844", + "0x03ff3b6c066342b657a8583acef6fadbc8e390be6e1fff8dc1526a05f16f2005", + "0x294aa2b063a035c26fe57d58d15931cdc79a6a94edf097d5347277f6e4b0f9da", + "0x0aced6fe68143f4c7acd16345a8c1bb50c51a0692b760eb48728feb923d90757" +] new_archive_sibling_path = [ "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x11adf5c71bf95b1412dc14e3b7ec67fb80c20c436e0cd47b4b6140ff146679a4", + "0x2f559d93de6d3e8a6289d45995351f749463bcee0ee677456f8ee19347c27114", "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d", "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037", "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da", @@ -523,16 +561,16 @@ new_archive_sibling_path = [ accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.constants] - vk_tree_root = "0x11065543c9a42eac842466277ee9149b27403e398e94c6bba4f525931a2ac6bc" - protocol_contracts_hash = "0x24b2bd6e0456d2d2e64beb505010896a57017c6dedf7516d314d551720c3e6b4" + vk_tree_root = "0x1d51e7bb66dda198c072b182a8e4809fc6614d677c914af2afa9c5376f16f06d" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.constants.last_archive] - root = "0x2ec9fc22ae7001e2ada488cbd0ea07e1cf7f54e151dc2bb766e561636b02eece" + root = "0x0c2eb70ed9c405d7895991207fcf58411017ab8481fba43c23b8d01f9ee6d826" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [inputs.previous_rollup.public_inputs.constants.l1_to_l2_tree_snapshot] - root = "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" + root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollup.public_inputs.constants.global_variables] @@ -553,49 +591,49 @@ new_archive_sibling_path = [ fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.start_tree_snapshots.note_hash_tree] -root = "0x24543462563d01f3fa7d2995feb0568f0868807616f9135cbcec47610a688576" +root = "0x01612d24a146efc2df9d815a2f733c17486304424577ffb4232fe4cb0c94e1e7" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000040" [inputs.previous_rollup.public_inputs.start_tree_snapshots.nullifier_tree] -root = "0x0d5183688b388e23b4fe243d466e4d50acaf63d7afa00ca046fe2bf2e83db99d" +root = "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684" next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" [inputs.previous_rollup.public_inputs.start_tree_snapshots.public_data_tree] -root = "0x27b8cdfd5211a289e0aa40da120fa969649354b3a0084d32d1ba1aca6b16f5b9" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollup.public_inputs.end_tree_snapshots.note_hash_tree] -root = "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449" +root = "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollup.public_inputs.end_tree_snapshots.nullifier_tree] -root = "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8" +root = "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" [inputs.previous_rollup.public_inputs.end_tree_snapshots.public_data_tree] -root = "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000fe" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollup.public_inputs.start_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000552" + num_absorbed_fields = "0x00000000000000000000000000000000000000000000000000000000000004d4" [inputs.previous_rollup.public_inputs.start_sponge_blob.sponge] cache = [ - "0x0d5183688b388e23b4fe243d466e4d50acaf63d7afa00ca046fe2bf2e83db99d", - "0x27b8cdfd5211a289e0aa40da120fa969649354b3a0084d32d1ba1aca6b16f5b9", - "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" + "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684", + "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9", + "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" ] state = [ - "0x0e2949060fe0f2aa67a11a1f8c7449f74124ab122ca0bfcc6d1dc19dde1e5268", - "0x06620ebc6d7abb78fe8de2f9f66c4cabbe323d277ef8de952dd1b59cd36bee17", - "0x129daea73c37f015b42271c76bad72aadcb53b8a12b8fb40b708f528315f16a8", - "0x0bfe4f9fb5d9e711aff1b1f4c96be770b3717443ed65ea7907957428c2f24702" + "0x1e20e5a8cee556f890f804b4c34dfa9d0c0691184ef311d07a3360c7a3ed0abb", + "0x2f58f461552b8e4a5eb0e2390a113ced8ed4fbe200eae42042548cc471aa8302", + "0x0f289d4b3c928a76f3d6b02eb37d55a0bc9f5efe83f048e9bb6087c97ecd2629", + "0x030aab4986f4fd9cf6184c20046212db4094a9884e02d5fd5cb39b8c3fa73119" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000003" squeeze_mode = false [inputs.previous_rollup.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a9d" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a1f" [inputs.previous_rollup.public_inputs.end_sponge_blob.sponge] cache = [ @@ -604,10 +642,10 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x00000000000000000000000000000000000000000000000000000000b7e5c34c" ] state = [ - "0x251647a367a8890a0f46a380c4abec7d4fc45dca0d143b8bf2a7cab6ceddeacd", - "0x14836cbe2cbe01805d670f7f2eb6897f238ded38492f38c58e87151837510c83", - "0x2abc8296d1c1b8a8fd8d517bd914bef6b2449373e5c5faef8fc8ec0b9d245412", - "0x0b49d4c777c2e81c0a25196c5bb03afdebef659fec11fe6945142517ae1a02fd" + "0x03a9c278ef420de34c98d3ed9353652c050aa787564e29869ba130c93aeeb58c", + "0x04840897fb96b980247599b309da2659be7d79a529b8e120a3de7d0ce81a18c4", + "0x261c3adfec1a9c39f94e54687fc959511aa357d07907d7eb60b6c1ede39dc9f8", + "0x22aeae6b14550f3d8954f9f9098c4255a25eabe1d0e5e6c662a8917c3d1a0e00" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" squeeze_mode = false @@ -615,13 +653,13 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 [inputs.previous_rollup.vk_data] leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000008" sibling_path = [ - "0x20ab775da5bb45344ffe17866237142b9321b97b2e93ccfb1c299476a262e0b5", - "0x2a9ef81b082ec4212c08eba71c46e645efc1ae573e9cca5b480785be9dcc4d21", - "0x18b9d1703288fad007e0e97212dedf18305ab172790fe8d5c7aeea5c2634673b", - "0x0481dbd69f3e084904030eb9771134ae7be848ec7b4af69e75933270ceeb544d", - "0x1fe698f1a6368c855525a9abcc3713bb49b1dec627f796bf4e23cc86473621ec", - "0x1c7b07f7b3f8344fece2e6a10bc9480dc4b90f89d2a51f344bee80ca5a4bda6e", - "0x12ed8e93726f8b5b79d1291566a72c1775861d60bba2daa19edb3f28d0ae7a3e" + "0x10b6730f1d1e9c6bf8d7c4b42b64b40d2603e3ae6ddbd464c3d8fcfb9e06e6d4", + "0x014ffec160e37b6cb713c1a4e6e7058964dde1733e6734520ed72f72fd262919", + "0x14bb1983f28c88ab603e0fe7e46b743829816df364ec385e2245072c3dad3e1e", + "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd", + "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d", + "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", + "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd" ] [inputs.previous_rollup.vk_data.vk] @@ -629,46 +667,46 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x0000000000000000000000000000000000000000000000000000000000000017", "0x0000000000000000000000000000000000000000000000000000000000000042", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x0000000000000000000000000000001393476211d0127a80dce177bd2139b525", - "0x00000000000000000000000000000000000a64db7a774dad381e4034cb2457f3", - "0x000000000000000000000000000000d5fb425ef17d829bcbd2f2212397cc69ba", - "0x00000000000000000000000000000000002902ad5d5e880ce9d3ff8815ad1554", - "0x0000000000000000000000000000009b94b4b71ebf49ca1ccee622099eb37a96", - "0x0000000000000000000000000000000000217517f2a6d3c0ad2a63c69b28d392", - "0x00000000000000000000000000000038d8df60934ce84e0ed3e7f5ca09c1ee4d", - "0x000000000000000000000000000000000013384c8161e64209078ece69fcaa19", - "0x00000000000000000000000000000093c2a0c6ec49f39474bd6782c5cd6b01b2", - "0x000000000000000000000000000000000008ff5813561afc758759d27f19b55c", - "0x00000000000000000000000000000097291956465f3aa94d25b11bc567a6c287", - "0x000000000000000000000000000000000007f14a03af147b21368785d869ca98", - "0x0000000000000000000000000000006a811b91c5970c9c2acd7a754d7b7f9cb1", - "0x0000000000000000000000000000000000190a1ac15c24fdafc83b205b9a284b", - "0x000000000000000000000000000000b61bdc9c40c5c1e94e290d7b383b2ee122", - "0x00000000000000000000000000000000002f5117ca48de83b07881d30427d341", - "0x00000000000000000000000000000012095bbac1cead43059d0a230818a027b7", - "0x00000000000000000000000000000000001c7b3a018ad17b7cbb3752d56c6f80", - "0x00000000000000000000000000000018c18cff602c8434b90273cb1ff38dd751", - "0x000000000000000000000000000000000003bd5bfa0c05c005fcbde355422947", - "0x0000000000000000000000000000009dac7aa803151cb1966b812422755d8e9e", - "0x000000000000000000000000000000000010f818617b14b429abcd3acd46653c", - "0x0000000000000000000000000000007951c87d59a7b4319ddc32a19635675d94", - "0x000000000000000000000000000000000005be6b96d6eb897429b815388db99b", - "0x000000000000000000000000000000d7e7c851d3ba4e42b00b50dcb9a40159ff", - "0x00000000000000000000000000000000002750be703cf6981c927c48de088588", - "0x00000000000000000000000000000048b23b4fb077032ac487b882dec8a8c38b", - "0x000000000000000000000000000000000017150b214b8aa285fed8a5b374a4f9", - "0x000000000000000000000000000000416e099bfce67a459c5a20a4311705f6c4", - "0x00000000000000000000000000000000002b684b94d2f1f96e86dfad7af6171d", - "0x000000000000000000000000000000651160cf941fb73a15062e12bfc9e35804", - "0x000000000000000000000000000000000007a1bb9d8533d71515e6e3b5e6866d", + "0x000000000000000000000000000000ed9a7d2d4e3143f585e5d95ca0088bd58c", + "0x000000000000000000000000000000000017f0f4eaca0b57f0254c56d1dcedf7", + "0x000000000000000000000000000000ecccc921a1dbc3116699315b30064501dd", + "0x000000000000000000000000000000000007fad76ddbb6ce8aaca29ac003544c", + "0x000000000000000000000000000000a58f237d5e3447619bd4995b6ab57329f1", + "0x00000000000000000000000000000000002e515ae24d7f583b5f5100e24e3a7d", + "0x000000000000000000000000000000c609b48ceeef44433a6570619898618e60", + "0x000000000000000000000000000000000021d92d4fc9578a1a92cadfd56bac1e", + "0x000000000000000000000000000000b9399d03a2bfe064a77805cd6299a18123", + "0x00000000000000000000000000000000000db15007f51cf45f0d4b5d0c72323f", + "0x0000000000000000000000000000002a813d4b748008a99d0bd98951733eecaa", + "0x00000000000000000000000000000000000006073a97f000f318cf4a87829a35", + "0x000000000000000000000000000000668d42870be7a506027fe80fdc5dd724aa", + "0x0000000000000000000000000000000000280e58b7658c0def5e89405371531f", + "0x000000000000000000000000000000748c0c2a74f8b51f4be7e8609a786d38fb", + "0x000000000000000000000000000000000007c3968791160ba6c2797f72cd485c", + "0x000000000000000000000000000000c047c85668bc7b41958055de15710dffb0", + "0x00000000000000000000000000000000001d09d1eb7e5a7fe0f1ae561fb471a5", + "0x000000000000000000000000000000ad226461b40c2b3ce2ce71eb9b3489b875", + "0x000000000000000000000000000000000028f73ffcd9c4f10b332da3c4202321", + "0x00000000000000000000000000000081bb4666343407adfaf6483652850334e8", + "0x00000000000000000000000000000000001904e26bb7deea88b240fd9f64d6c2", + "0x000000000000000000000000000000046a09098559eb29059aaec545f1b60ab4", + "0x00000000000000000000000000000000002eba2495a17bb6751670d141eba5bc", + "0x0000000000000000000000000000006d4c6812176142054ef8b72fcec9ab1d46", + "0x00000000000000000000000000000000002f17523cebbe0a959a3d3ad4008621", + "0x000000000000000000000000000000fea01dc8a40e8358627aefbdc809f0d16b", + "0x0000000000000000000000000000000000255b95149080440a22c012db52d174", + "0x000000000000000000000000000000b5e6e229f22d5d6130b6940f897bd687ad", + "0x000000000000000000000000000000000002c1d364ecb3f8b13d39b364b9fa17", + "0x0000000000000000000000000000000ace98195a1e28904eeb54e8f1beab8965", + "0x000000000000000000000000000000000021ddb285f5b40df25978b16f38fa55", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x000000000000000000000000000000bada1572761d2d57e5d206da78afa472c5", - "0x00000000000000000000000000000000000248453a876b49502a5a8259818f44", - "0x000000000000000000000000000000ec45f0511c4ef04800c3d31e152e9265de", - "0x00000000000000000000000000000000001fff1bef8afe963c3b78c3c2549ca4", + "0x0000000000000000000000000000009723288bf6b623aceeea91e62d1533d690", + "0x0000000000000000000000000000000000015e128393cc29fc38e815d2a2c8bb", + "0x00000000000000000000000000000034f5a0b8bdc854f056ab93f34153f52607", + "0x0000000000000000000000000000000000239dafd7ff901c78c54dac6ef232c4", "0x0000000000000000000000000000006f206a04895661d3bd004222a1f8a7fc73", "0x00000000000000000000000000000000001b12a59a820d3aa543a594a1b9d92f", "0x0000000000000000000000000000002103559842aca1e08af33bb1f714ebc02a", @@ -689,57 +727,1109 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x000000000000000000000000000000000021a0543de0bc42d6586454ec8b623b", "0x00000000000000000000000000000016bf0724359c9a09ceffdc9371a2d6e5dc", "0x00000000000000000000000000000000002fd4c13c6f5523a7f44b28ce3d342a", - "0x000000000000000000000000000000e379faf5ffdd383be5ce0f1ee38f5e73fe", - "0x00000000000000000000000000000000001429616496865cd170bc83c40d415a", - "0x00000000000000000000000000000066e08b7ad48415290d2ff590e84057e60e", - "0x000000000000000000000000000000000023a625e90ae9701e33c52be8f0d396", - "0x000000000000000000000000000000774fc954a6adaa4e4db1da6228184e1354", - "0x000000000000000000000000000000000015ca4073735e39fd5dc55567dc1068", - "0x000000000000000000000000000000fd9e5f594db01e4b2625e1e3dcfd400f6e", - "0x00000000000000000000000000000000000f4a392bbee96bddd468b2c9a18896", - "0x000000000000000000000000000000d28954aef28e666d63ee0fb401ab7bc1b6", - "0x0000000000000000000000000000000000253b48f95132d1a3183e26dbd56884", - "0x00000000000000000000000000000022887784410bf17c157fc004401281c342", - "0x00000000000000000000000000000000000a249d88427c50df84670228613493", - "0x0000000000000000000000000000000f495c15c8a9098c779fef9227f1c5a897", - "0x000000000000000000000000000000000016d74e40a54fe1961a01c0a275941e", - "0x000000000000000000000000000000a968320348365b69bc59ded07a855fb88c", - "0x000000000000000000000000000000000010c9846c3754b0fb4b4c9ab8d68cd3", - "0x00000000000000000000000000000088ee0f0a54893f8b1e8b56a7fa7bee9d4f", - "0x000000000000000000000000000000000021d14db4aa9ae9f88641b9336d9dba", - "0x0000000000000000000000000000000f46a800020405196bda0c07afe5154eac", - "0x0000000000000000000000000000000000062e98c038c271784c9fb61136242f", - "0x00000000000000000000000000000024ed87f3417bd5bbaa53682680b1b915c8", - "0x000000000000000000000000000000000003beb3d385de2c0a7a40cebe01d34a", - "0x000000000000000000000000000000f85b812b32412267c5221f3600eaa3f3d2", - "0x00000000000000000000000000000000000289ace5de4f3e7a721b5a184d1e76", - "0x0000000000000000000000000000002e30085e1c74fe70d1d2ab68faf0984ca4", - "0x00000000000000000000000000000000001adb7660db50eb3c9d70b137871b2f", - "0x0000000000000000000000000000008e05ae370a270eeb6d282e3bc2b7889cc3", - "0x000000000000000000000000000000000020e76f33b00bccd1f97095bece663a", - "0x000000000000000000000000000000d71d8a40f7c9f1984d513aa7eb1a895e6e", - "0x0000000000000000000000000000000000021aee4d83119d0af331d5893af9fe", - "0x000000000000000000000000000000dec3abe29c9aa4bf73251a0c748d11e9dc", - "0x0000000000000000000000000000000000153c1ed58f5394ad372869f471ca8b", - "0x000000000000000000000000000000bf4d6e6ed9dad1b05bd3d5cb3b3740d3e2", - "0x000000000000000000000000000000000006803b1ef715809ab5085220b7c284", - "0x00000000000000000000000000000041efece86e20c4323fb08d7aad7345c79c", - "0x0000000000000000000000000000000000096fab6acc87fe26e0eefb5660a7db", - "0x0000000000000000000000000000002d550983acbdea743f381bf4d55b8c6110", - "0x0000000000000000000000000000000000107455727dcf49837ee29622f4e9ae", - "0x000000000000000000000000000000a07bfb26d2f33a45866564f6fb630fc1b3", - "0x000000000000000000000000000000000004b58a9a3d784d5857e224b300b97a", - "0x000000000000000000000000000000c0f8d7d2fa6eac6b45b736e838db02e437", - "0x0000000000000000000000000000000000012728fef15749f6355802ac76d166", - "0x000000000000000000000000000000caa9dd21f786e491093e94a42326c20c4b", - "0x0000000000000000000000000000000000181c00a5273565ed45cde6516b7267", - "0x000000000000000000000000000000f791b0a7d2376523eebf266bd58c615a72", - "0x00000000000000000000000000000000001658c7b51e5eb76e58124a4bf26d30", - "0x0000000000000000000000000000007ffefc9b69f9b9f766f98d9390ad49a8f6", - "0x00000000000000000000000000000000002700900f023bdb2524f5ce218af8a6", - "0x0000000000000000000000000000001d12e2e9feedc5df84ac9cb8e405fc64ea", - "0x00000000000000000000000000000000001645d7c72fd8844ddf0659d2b77656", - "0x00000000000000000000000000000098eaadb9c8f156e98d8dfde6f90be22a80", - "0x000000000000000000000000000000000028291c89dafd88dced57d87f6d8ab7" + "0x000000000000000000000000000000983b80f553a1f41ea4a613c4272296aa6a", + "0x00000000000000000000000000000000000fad2d11baaeba59740ea2e1e556ab", + "0x0000000000000000000000000000000df8dad25aabadfb2fd689e927f28e9905", + "0x000000000000000000000000000000000006e77d6620186fb40fa775055f6e02", + "0x000000000000000000000000000000ab530a3e0bd1b4d58d3462aaa5248378ec", + "0x00000000000000000000000000000000002128bebd2165991c478744366c2660", + "0x00000000000000000000000000000069959e29b21942c9bc6095c81c52e09e2e", + "0x000000000000000000000000000000000029521e97be7f1262547599981f9dfc", + "0x0000000000000000000000000000004b83cde93267991f2e75cb58d8c62fc648", + "0x000000000000000000000000000000000024bda0836d4ea3d2e8d16bb8b929ff", + "0x00000000000000000000000000000039b6192602f956e962d51c4dbe711e46b9", + "0x00000000000000000000000000000000002b58de5dca4604474742cc42f7a05c", + "0x000000000000000000000000000000dc0d4adfc6bbc96e9863eef8920e82c85c", + "0x00000000000000000000000000000000001c791e40bb700a33ba6343f2d60474", + "0x000000000000000000000000000000213ba680b5b07b331f0153faf572881700", + "0x00000000000000000000000000000000000d2a671fdcd41097454dedb403cf28", + "0x000000000000000000000000000000c40c6f11a42754888c5d0cac2acc5c2e99", + "0x00000000000000000000000000000000001f95faca5af29481f878207f1f3461", + "0x000000000000000000000000000000af74c82994a772d5816d23cad77f507de0", + "0x0000000000000000000000000000000000298a0a94c391ad23bd2714cd83d85b", + "0x000000000000000000000000000000f118536b214a0b173d683952cb179f7308", + "0x00000000000000000000000000000000002048287f58cbf84bd0bdaa216b750b", + "0x0000000000000000000000000000008b7b9a9326671e5fbe01204632efe954cf", + "0x000000000000000000000000000000000000e6e717ef9fe95faf3dc3c94585c0", + "0x0000000000000000000000000000003d73274d5823c057df53030584e69fb7df", + "0x00000000000000000000000000000000001197cce7dac8be65e92fadb47c7e53", + "0x00000000000000000000000000000075d310ff38e2775418a123dcca24d43741", + "0x00000000000000000000000000000000000ca18eff9b17d5e1a103b5c931c576", + "0x00000000000000000000000000000031323a2499d3b128f28b1305246959409a", + "0x00000000000000000000000000000000001dd443e2b9f240a6f8b9b4e29987d3", + "0x00000000000000000000000000000050fea0738e4ca6015860a1370ea49b70a7", + "0x000000000000000000000000000000000017bce74645c162884adc4a6fb7a907", + "0x0000000000000000000000000000007b57ed2a44bfcffc4fc896d15c31ad0d1b", + "0x00000000000000000000000000000000001e4d34edb06ee6ba520d1db5080d9c", + "0x000000000000000000000000000000db1a4b059c0f5fe3e9df6ff8e0d192aca3", + "0x00000000000000000000000000000000001a05c7210c56b6bcd1dc18cff662d9", + "0x000000000000000000000000000000e67e3c5e07fbdd021dcf504db8c63d9b7c", + "0x0000000000000000000000000000000000252935e626c53fe844eb3b48575177", + "0x000000000000000000000000000000c2b7a9a8d8d31df906bb3d90342b9deb2e", + "0x0000000000000000000000000000000000090be4375322103f7233fe4dc9aefe", + "0x000000000000000000000000000000ef6397346da2082caf01b01d285e62e79a", + "0x00000000000000000000000000000000002e6d903371b2347a7cee9a53b3ff86", + "0x000000000000000000000000000000c121fa0e4904211f7d8bd7bed351379d29", + "0x00000000000000000000000000000000002a144c122f68e5b0b50412e6c3341b", + "0x0000000000000000000000000000003cc64d54b35537185ca0399b5e8103b296", + "0x000000000000000000000000000000000004ab8b6bb82552fccc8b2d8b078787", + "0x000000000000000000000000000000d679c88a95d67824fb6cd1be11125f4134", + "0x000000000000000000000000000000000001406dc68a75534a42bc313b9789a6", + "0x0000000000000000000000000000007f458ba267d25862d28eead635c9f44260", + "0x0000000000000000000000000000000000176c2fa161d670836afa9958b8ee4b", + "0x0000000000000000000000000000003ba1cc971819aacf0bcb421bd3aead9f0c", + "0x00000000000000000000000000000000000366f6e08da4f6c87b3393784388b0" +] + hash = "0x2597d0ee94af6c241e63bc541fabe57e418d679cdeb426bc76fe81a01487c4c0" + + [inputs.message_bundle] + messages = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000000" + num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.previous_l1_to_l2] + root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.start_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.start_msg_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" +] + state = [ + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" ] - hash = "0x016a3b94e0b04a9f99ca3c31a475b4b5b1854bb2f3cea14fc49177110c9d7142" + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-block-root/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-block-root/Prover.toml index 84fd2564c7f3..4d66dba58d6a 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-block-root/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-block-root/Prover.toml @@ -1,7 +1,45 @@ [inputs] +l1_to_l2_message_frontier_hint = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x2c7fea674d2d40f18ffc3f161020dcd660472023bdc7774ae7cdf7b250153f4d", + "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad", + "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da", + "0x1077e8e59029b12e321c47a8a2a25283e50664b6ca1dd766a83828ddc6a22bb9", + "0x15b7bb46f75a6826da53df52c290eda3ddea8924becad6e9a3c08e4eb9a6f604", + "0x0f092097aaee3e41e55706add0701d0eff7a0c972a909dcbc915a478cbc8f122", + "0x2cf33c7d57e1ff8f3d98aabae3092befa8e92274da5e6d324ba0b8839889d27c", + "0x137e350aaf8bab893d768cb6e14bc5464877833efbb8c7091da9ecc7a96bc7b7", + "0x016505cc51b09b257b8c96b5fb20e90bd9e68416286a904d9f86b805e5a89e13", + "0x04d6e1009a70843f5bad89c59765d09421aad04e3276fc90f2a459565057978a", + "0x093a8215cd7e725a45949f4d6d4faec9d078221f09d26a27d61e4f0bf670a580", + "0x1704545cd66b0aa172d2c355fac161d17d7ea42f0132d24708762b544fa17357", + "0x2db6ed73abe6fc42bde50d4422c3e0c81def268d702b9256b7e67cafbbd0325c", + "0x21868e4f8cdcbcb9754d297edc2a361754517465c469017e784a4347f9eb6644", + "0x1adbb821ee5346b1979da8ddbb58789f5ef90c31ece8f0c543c221a3ef0f0aed", + "0x2058aa06a8e23bc53a625831ce1df1aa8d8f01924ad840607f33805aee179d90", + "0x1002be9f0852a234617c837e49555e328bb19a71fcea0ff34368901cee52c85e", + "0x2b238a0d25b834a061e45d817289ab221d13fd0e4cc7adf72d91d54c280f1aa0", + "0x15fada375c113bd526097e297b422ffb59f54a5451e5b70d4a4b028dc65208d1", + "0x2aad701e57c7069cb4e148d971c0eae9ac7429d7d833c51d87875ead0c5aca3c", + "0x2403f18ba27f090c40c95fc6724d67b4b7d537b967ee15656c79e55284df9d6b", + "0x13404ebc0eed291ffb14cad19114bad8df35bae99793ea99e4dde966cb4e53ad", + "0x006a1008132293c19aafbe7130eda035bd1b90065032894071b1f390f4946844", + "0x03ff3b6c066342b657a8583acef6fadbc8e390be6e1fff8dc1526a05f16f2005", + "0x294aa2b063a035c26fe57d58d15931cdc79a6a94edf097d5347277f6e4b0f9da", + "0x0aced6fe68143f4c7acd16345a8c1bb50c51a0692b760eb48728feb923d90757" +] new_archive_sibling_path = [ "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x1f46c86bfadbdbf682291d06e0af66ce58d17ab72005b68b73fa4217e517024d", + "0x284d753011a1544ea66ccc1024bcc2aef83468522f0151d20454f31a06424e77", "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d", "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037", "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da", @@ -517,22 +555,22 @@ new_archive_sibling_path = [ ] [inputs.previous_rollups.public_inputs] - num_txs = "0x0000000000000000000000000000000000000000000000000000000000000002" - out_hash = "0x00bd3da907cbb210cd100bd369f8dd7eb04b938c69dce277dc1efea8403ed88e" + num_txs = "0x0000000000000000000000000000000000000000000000000000000000000001" + out_hash = "0x00fab7a43a18caf54d1e3dd82cf6d3def175265507c701576b015603f4dd1b44" accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" - accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000" + accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0" [inputs.previous_rollups.public_inputs.constants] - vk_tree_root = "0x11065543c9a42eac842466277ee9149b27403e398e94c6bba4f525931a2ac6bc" - protocol_contracts_hash = "0x24b2bd6e0456d2d2e64beb505010896a57017c6dedf7516d314d551720c3e6b4" + vk_tree_root = "0x1d51e7bb66dda198c072b182a8e4809fc6614d677c914af2afa9c5376f16f06d" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants.last_archive] - root = "0x26c404240cb9d3965fdd677de1d4ea1d907e460403e304ed198e839901a4cebc" + root = "0x22fb435f1b17b06f994e96f8b9092935bb52d7ff089f9da911deb76fb11eafd0" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [inputs.previous_rollups.public_inputs.constants.l1_to_l2_tree_snapshot] - root = "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" + root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.constants.global_variables] @@ -553,126 +591,126 @@ new_archive_sibling_path = [ fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.start_tree_snapshots.note_hash_tree] -root = "0x2590f2aab19dd791700b4a43d3f52bb88ef2409a3731da8e848663559202e4c6" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" +root = "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.start_tree_snapshots.nullifier_tree] -root = "0x18935581a8ed73d08ffd00386fba55ba6c89f3ab848a76b8fedfa9034cee0454" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" +root = "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" [inputs.previous_rollups.public_inputs.start_tree_snapshots.public_data_tree] -root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollups.public_inputs.end_tree_snapshots.note_hash_tree] -root = "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" +root = "0x144f9224dee4aac6eddc5d988e7c6965528d2e08db91cf58989655a68fbfcc52" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" [inputs.previous_rollups.public_inputs.end_tree_snapshots.nullifier_tree] -root = "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" +root = "0x191d19a6ad2b7bba03d122035938544f5e65de24aeaa436cd5e4d977bd014505" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000140" [inputs.previous_rollups.public_inputs.end_tree_snapshots.public_data_tree] -root = "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000fe" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollups.public_inputs.start_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000007" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a1f" [inputs.previous_rollups.public_inputs.start_sponge_blob.sponge] cache = [ - "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922", - "0x18935581a8ed73d08ffd00386fba55ba6c89f3ab848a76b8fedfa9034cee0454", - "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" + "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759", + "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b", + "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00" ] state = [ - "0x0f19f1d5a0d014c8f9cb5070b6a72c7efb81b4971bc364738cea68076cfc9128", - "0x1e62eaea4ad0390925cb2382c5f4dc22f4d23495e0890061050f08c37ca8c9cd", - "0x143fae3a86f2ed36eca31eccf44ce149d098395a86dd8c9d541a15c155870153", - "0x2643afd339189b520e780ca47df76348b0d58825939d38dd1b1b0df9e8239947" + "0x2a5cf7199bc1a5f8871b4fea5c6f99f5dba43db93b819ca26d2fa8dbbdc1f82c", + "0x011cf649f43e718babd7d68caa9d36ccebf49e536e764b6674fc8ca18e8a4ada", + "0x17d68b99d3347b9908ca791c2a098777db49c111ac24b850a48e36fd0329b4e4", + "0x038347b13467b09e427b9f4154c2d36b1cd02bd1b08d8ea406687512f0b16a79" ] - cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" squeeze_mode = false [inputs.previous_rollups.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a9d" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000eec" [inputs.previous_rollups.public_inputs.end_sponge_blob.sponge] cache = [ - "0x00000000000000000000000000000000000000000000000000000000b7e5c34d", - "0x00000000000000000000000000000000000000000000000000000000b7e5c34e", - "0x00000000000000000000000000000000000000000000000000000000b7e5c34c" + "0x00000000000000000000000000000000000000000000000000000000b7f9d44e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44d" ] state = [ - "0x0b7c9bbfac21d3c59031a865ee1f7abea9012d898a238d0b9d545e7e15be4f9a", - "0x11e47e7e5a97cace7b8cb5c63eeaf7cb076e5e19a4e89c1d3f4c3fb1faddf0b3", - "0x03a1357263e162410b5a70343adea4b373f3006660d9b40c28425be41749a8f7", - "0x100bc00d33720748142a7cd2ab57c5c140b681cdeec9b6197841f983ed05a3e2" + "0x2d2cd78abcdb723be782846e1ad64ae3ab9aa2260689da6ae7475677befc11c2", + "0x0250e73c2089d502af086b4d31fc90a61b62f71901e93588a19421c1e54417db", + "0x1225c74c7caef02691c6f3a18a18ed4ce10675ec8286339594bef2cee3bcdf01", + "0x0b9145803dfcf3b0958502feb867fdbb62eb5726361b0971f704ffe19719c0af" ] - cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" squeeze_mode = false [inputs.previous_rollups.vk_data] - leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000009" + leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000007" sibling_path = [ - "0x016a3b94e0b04a9f99ca3c31a475b4b5b1854bb2f3cea14fc49177110c9d7142", - "0x2a9ef81b082ec4212c08eba71c46e645efc1ae573e9cca5b480785be9dcc4d21", - "0x18b9d1703288fad007e0e97212dedf18305ab172790fe8d5c7aeea5c2634673b", - "0x0481dbd69f3e084904030eb9771134ae7be848ec7b4af69e75933270ceeb544d", - "0x1fe698f1a6368c855525a9abcc3713bb49b1dec627f796bf4e23cc86473621ec", - "0x1c7b07f7b3f8344fece2e6a10bc9480dc4b90f89d2a51f344bee80ca5a4bda6e", - "0x12ed8e93726f8b5b79d1291566a72c1775861d60bba2daa19edb3f28d0ae7a3e" + "0x1fc39d0a428c8536dbca551ea79848acf67d89d090fd8c643c7d90f2e8f32340", + "0x12ce5a49a1ceca53ada7bee003f929bbd65abaa74e8072a81f304c2c96c44e31", + "0x2dd71474f7775d87b6c2986ace5f654686583f0970d7400b1ccf8096dad131b5", + "0x1bd9ea476112f37bb5ce44ce3c3f0d2e62e20993253269166a016eda81ac1007", + "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d", + "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", + "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd" ] [inputs.previous_rollups.vk_data.vk] key = [ - "0x0000000000000000000000000000000000000000000000000000000000000015", + "0x0000000000000000000000000000000000000000000000000000000000000016", "0x0000000000000000000000000000000000000000000000000000000000000042", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x000000000000000000000000000000caa1598dca4e37d78572fa4a673fe48fcf", - "0x0000000000000000000000000000000000016ad6643bea8ee78b1a225f498d9e", - "0x0000000000000000000000000000003cbf301e1f115d44eb4a073858500d1f90", - "0x000000000000000000000000000000000021c73a326143da86ab5fc585cf4246", - "0x000000000000000000000000000000d7da14c2cab8ecde96bacd6d6f2430424f", - "0x00000000000000000000000000000000001e870057fcdfbadbaeeac10640a097", - "0x000000000000000000000000000000704a325b3d5a903c262c44348d7a86d0ec", - "0x00000000000000000000000000000000002de4239e3d91df4477e49132bb87b1", - "0x000000000000000000000000000000a27bf5a15e26f43aa820086e335f7ad09d", - "0x000000000000000000000000000000000002165a625977654e98dd9b723c14e8", - "0x000000000000000000000000000000c3637de63520e9d9372c17571b5e739c1b", - "0x000000000000000000000000000000000020e48513502d9c415ed9fe14629d15", - "0x00000000000000000000000000000012349c04470abdf58fb01a7d0fe24cdbf3", - "0x00000000000000000000000000000000001f239046e3013028e98434553690c4", - "0x00000000000000000000000000000095caedf215800fdd92feb9986cd1a88723", - "0x000000000000000000000000000000000009d26dcd344fe75c8f35c7479f511d", - "0x0000000000000000000000000000000111cfbbe08f8b821450d0b90c0f1070c8", - "0x00000000000000000000000000000000002558314b5fb8680380616e72d0c053", - "0x000000000000000000000000000000995f7ab83bc05dcda1afb1372e59cdfcc7", - "0x00000000000000000000000000000000001aeb91af1f30c02dbbd36a98cc2231", - "0x0000000000000000000000000000006221173072fa9551c663afb6209fdefa2e", - "0x00000000000000000000000000000000000e171ef3e60f887b0a7cb618e7711c", - "0x000000000000000000000000000000b3bbea9329a345198e3fdfe3505b99df4a", - "0x00000000000000000000000000000000000dbb8cbe2b75c09a2a82ef538290e5", - "0x0000000000000000000000000000004ded14c1b910011b99fd16df857fbc58c6", - "0x00000000000000000000000000000000001faa5965c5913bd455ce44b99914e5", - "0x0000000000000000000000000000003027abdd2d8b5ef2e2bc25fabdd211a6fa", - "0x0000000000000000000000000000000000034a596c8cadd90d73bf17fc3afffe", - "0x0000000000000000000000000000005518194ea9887921d16cc389a54bf3832b", - "0x00000000000000000000000000000000001ce989b3df90479090b78e92b638ab", - "0x00000000000000000000000000000080f0ccbf9cfb73dfb6b8873a2851742359", - "0x000000000000000000000000000000000003650108505c9b45bbf70c2d6b7378", + "0x000000000000000000000000000000165ae78531927a33f65caca2e363cc772e", + "0x00000000000000000000000000000000001241b6b86155467b26edfdab7ad6fb", + "0x000000000000000000000000000000b2d0f5b63f894b62d0e60089db80e58d27", + "0x000000000000000000000000000000000008244c501ee23523df6c834feb0e11", + "0x0000000000000000000000000000008672371fd2ce392b4b429418037d12162a", + "0x00000000000000000000000000000000002c7ce75950c33d18096163daf9cab6", + "0x000000000000000000000000000000d87658c101442505855988d5a754acdd88", + "0x0000000000000000000000000000000000137ad22d525a7eff2a2109fcdcae7a", + "0x0000000000000000000000000000006d12443f95a71b142723a798780c49adbd", + "0x000000000000000000000000000000000004e32eeb2532de9b992573f60e45dd", + "0x000000000000000000000000000000df1cbb627e3caab74cabc8712ac00362e9", + "0x000000000000000000000000000000000002e2f623a0fc048dcc89df75393191", + "0x0000000000000000000000000000000b53b2e19c6b1e9cd32e3cf643c416a59d", + "0x000000000000000000000000000000000020bf4d595cc2a10d2be49c507e7e96", + "0x000000000000000000000000000000a86601635b08eeb4993a1cf4033bf9d227", + "0x00000000000000000000000000000000001024c89eaa5827b94a3e6a6f6e2abf", + "0x000000000000000000000000000000f969a6c5173db0b28983bdd5834d3f6474", + "0x00000000000000000000000000000000001ef6a1853c5a97d42e27f8f509574e", + "0x000000000000000000000000000000c1e8d3777151f0521862bfc28f127f0258", + "0x00000000000000000000000000000000002172f71d7b12ef29e40e35f0eb792e", + "0x000000000000000000000000000000d1cf7d66f4a4f6d8e6dcd87fae8754a47c", + "0x0000000000000000000000000000000000281939574f4672879eb703d4d4de39", + "0x0000000000000000000000000000007c7be15eb86fc3e2098e8d224df92270e9", + "0x0000000000000000000000000000000000067d8f76b31d288f52990d7b851906", + "0x0000000000000000000000000000004e4d9ad79291ec12365024f1d5fee16595", + "0x000000000000000000000000000000000020c38b4a8b779b59231117e040791e", + "0x0000000000000000000000000000006fb68858ec3efdae8d238910eb3d7c1caf", + "0x00000000000000000000000000000000002e13d2da09f5dcceb4c2a40e0771c3", + "0x00000000000000000000000000000005ee27483337e5bd9c68e2d9b8685ea567", + "0x00000000000000000000000000000000002785f7e22fca9657887d9b32a7a423", + "0x0000000000000000000000000000005691107b72691b16467cd087d930a639e9", + "0x000000000000000000000000000000000026d6131e96f4a016e33fac0ba06f18", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x0000000000000000000000000000001256412563febc9d3d73639a002e1fc9b9", - "0x00000000000000000000000000000000000620a3d4eeb54142ca75e2dba2a4db", - "0x00000000000000000000000000000039917c91cc366fd4912cb7be248a35233c", - "0x0000000000000000000000000000000000092472bf677235f6956f2d093c008b", - "0x000000000000000000000000000000b1795305b34f2f47e00fefef8e3ff03117", - "0x0000000000000000000000000000000000219d203b492d7debf5d8e7df9d2059", - "0x000000000000000000000000000000bfa96395c8478bacb512c36590c5b7b901", - "0x00000000000000000000000000000000001088537efb9ccd4bbaf4c519fb15ef", + "0x000000000000000000000000000000eb965cf70d77f0e2216d04c748f3ab7f5c", + "0x00000000000000000000000000000000001beaa0afc9b05bdf71db514a814532", + "0x0000000000000000000000000000006cd09b0a30f4a93136c9860b93dcdb5bcd", + "0x00000000000000000000000000000000002dd6a841fe0c0bbe07a71c827501f5", + "0x0000000000000000000000000000006f206a04895661d3bd004222a1f8a7fc73", + "0x00000000000000000000000000000000001b12a59a820d3aa543a594a1b9d92f", + "0x0000000000000000000000000000002103559842aca1e08af33bb1f714ebc02a", + "0x00000000000000000000000000000000001b8936a0be628b58af9859c2a851d1", "0x00000000000000000000000000000016c08d152f9dc697daff20714fccf7a5ea", "0x000000000000000000000000000000000021414e160dd06b07bdc4cfc47e4e2c", "0x0000000000000000000000000000002a824f2fcf5190d78d4fc5975ad848a5d1", @@ -689,60 +727,60 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x000000000000000000000000000000000021a0543de0bc42d6586454ec8b623b", "0x00000000000000000000000000000016bf0724359c9a09ceffdc9371a2d6e5dc", "0x00000000000000000000000000000000002fd4c13c6f5523a7f44b28ce3d342a", - "0x00000000000000000000000000000061405ee59edb83d219a4493604d8df8073", - "0x000000000000000000000000000000000011a34f74e4e97e31cd231a1b171c5f", - "0x00000000000000000000000000000065b8a5a2da7d378115003ef097e0ec1b33", - "0x00000000000000000000000000000000000d958a9a530f6138807471b9f00dd3", - "0x00000000000000000000000000000076fd099960d4125a29c7341d193feaa0be", - "0x000000000000000000000000000000000016d6a9f7c51b91e2097bb9cf70ca99", - "0x0000000000000000000000000000000066878c25e24883918ee19236dedf8e7a", - "0x0000000000000000000000000000000000239dea1597e850ac7b8beeb2919d9b", - "0x0000000000000000000000000000009ac59b14d9350d9b422f319b3a0142a2ba", - "0x00000000000000000000000000000000001e91c8f0370d6d72378892ac071836", - "0x0000000000000000000000000000008a494943abd8f50dc5188d4b34bfc75a3f", - "0x00000000000000000000000000000000002bc55ee1a56f307dc6c11edf632e11", - "0x000000000000000000000000000000a3bbf9a024521bff63ac9ec84b2e102450", - "0x000000000000000000000000000000000026359bfd648ec54ad2a62ce0f56200", - "0x000000000000000000000000000000970c79863e1fe0ce9c7e5208046b8f7bc8", - "0x000000000000000000000000000000000011965004488f372d1c7ce8202eaa07", - "0x0000000000000000000000000000002c9193106d9b94c289d3cd6cf50b262a33", - "0x000000000000000000000000000000000025603e1f70d8b8958c93998d233876", - "0x0000000000000000000000000000009c11e9b5a22b4b61bfc97eba76026f4cd7", - "0x00000000000000000000000000000000002db5cd7ae62e323c72ec8c187a5aae", - "0x000000000000000000000000000000a93093ff27ad3f2d5cf1dd53ba2ee845a0", - "0x00000000000000000000000000000000001cec9ca40768a2cd1a17f6c7c9dbf9", - "0x0000000000000000000000000000003d900afb111be27899d10b78fc1ebbec91", - "0x00000000000000000000000000000000002dbc1ed8b7a9d47c0f41eb45ae9670", - "0x000000000000000000000000000000dc5cc2370e6ea2bd90453a121270b4e1c4", - "0x00000000000000000000000000000000001ee583c3be7e33fe5bb33c3c6607dc", - "0x0000000000000000000000000000005b8dbfac41f7f00686c9bea577999342db", - "0x000000000000000000000000000000000002dcdb63b4738aedce151a1a90ccbb", - "0x000000000000000000000000000000503652993795ebf9c48026d15d693a1d77", - "0x00000000000000000000000000000000000ade8b97f88d4fc37a5918ba95d655", - "0x000000000000000000000000000000f708293c9af0019712e8676e0f81532b9f", - "0x00000000000000000000000000000000000fac0307a594c5601eaad4b3a2ad05", - "0x0000000000000000000000000000006cf7268767d45ce8110619c21c9a214a2f", - "0x000000000000000000000000000000000012c49f22347c4caa3f2187e510e4ba", - "0x000000000000000000000000000000ee4d3060375318f5f489ff5a8f76135787", - "0x00000000000000000000000000000000000b248f2f9673f5135d11083ff4fce4", - "0x000000000000000000000000000000e239eb099884d7ca28e161a9aa1b91af81", - "0x00000000000000000000000000000000001b1973e513eed3e33431ef809a0e83", - "0x0000000000000000000000000000000c4e4edf6fb53a76bd35e4d7f3a15112db", - "0x0000000000000000000000000000000000145ba233c13b3914b4da7f9ec60fd5", - "0x000000000000000000000000000000ba214ccc13ebb1b9872f840d92212cb7fa", - "0x00000000000000000000000000000000000f318091b8546b6c346065a0421fae", - "0x0000000000000000000000000000001857cd22bc6e548e3a1326a38342380abc", - "0x0000000000000000000000000000000000258af1ecbdec237c4ca3e7c43e23be", - "0x000000000000000000000000000000ddcd935bfcbed61b2d5dfb467633cd065d", - "0x00000000000000000000000000000000001bdcff79947d7bf8717ff6af7eace4", - "0x0000000000000000000000000000002f0274569b50d632b7df62579a51700a78", - "0x0000000000000000000000000000000000110205f104c154f37db7ba03296738", - "0x0000000000000000000000000000001669ec30d62997299c6384897452e193cc", - "0x0000000000000000000000000000000000091f36af19ffa02534ed6c6a12bd77", - "0x0000000000000000000000000000000cc9c593f552b97588f6a252104231d75a", - "0x00000000000000000000000000000000002d0af598a89ca680fc9928f822506d" + "0x000000000000000000000000000000c3b10f88e5436be1d5a5a4bb53bff9f86f", + "0x00000000000000000000000000000000000fb0a6d38afc343e251396adad53cf", + "0x00000000000000000000000000000070e87b913346fb9285cbb00737bd57cf7c", + "0x00000000000000000000000000000000002853427de22e10d72478e05c2f3f91", + "0x00000000000000000000000000000052cdddc8f97be52a13f243728d141d2901", + "0x000000000000000000000000000000000015b1139f895206b7e0178e1fc8ba75", + "0x000000000000000000000000000000c13228904b731ff23df21fb368c575405c", + "0x000000000000000000000000000000000025b350c9a547af501a922cd9867da0", + "0x000000000000000000000000000000561589ea814180f093543e48a620ad996c", + "0x00000000000000000000000000000000001fdfc3b1f7112d4ef57921ecde0909", + "0x000000000000000000000000000000099a453cc185766d9aada7cfdb2195d3b0", + "0x00000000000000000000000000000000000e551b1e35be8e8c1a41cbc889702a", + "0x0000000000000000000000000000007ba452ee5e06e123c1fb5cb50dc27007e4", + "0x000000000000000000000000000000000011a0d4e994b8faea474106b96afe46", + "0x000000000000000000000000000000f6ae6d824f37161f26c6515e95acfe76de", + "0x000000000000000000000000000000000029e3bcc9a024ac817c64d605e34fa2", + "0x0000000000000000000000000000002fec07757b3dde0584f30d7df6edc93ec9", + "0x0000000000000000000000000000000000233b6a495366005b18f14a21c37ede", + "0x000000000000000000000000000000d14f4d9f26fea64507ff561fa97d53d9ab", + "0x00000000000000000000000000000000001fb840c0913e222b1da7e26b2b556b", + "0x00000000000000000000000000000005442bad0ec64b17e4b69cc2da15241cdf", + "0x00000000000000000000000000000000002c438af2970405edbb8817c9f71d19", + "0x00000000000000000000000000000088fb3d8a9b6438b9ae1291865d3ab9f50e", + "0x000000000000000000000000000000000007c124e2aa719ddd02048950ed3154", + "0x00000000000000000000000000000034b5893e41adc3972f5ef17616f217463a", + "0x00000000000000000000000000000000002a2e5b545fa30305e181c35d58b00e", + "0x000000000000000000000000000000792d2f9cddf98914ba6ea9c36d9419444e", + "0x000000000000000000000000000000000025b1802368323e36444739ecf3ea7d", + "0x0000000000000000000000000000002d1b5d30f1396ec48b39dec6d2e1d5e9de", + "0x000000000000000000000000000000000026313ea541baf2d94c8ec1df8851be", + "0x000000000000000000000000000000f9b58828fdb3a2c664caf3cd2aa329120e", + "0x000000000000000000000000000000000013a9abade9e01b580cea0d4ec81be2", + "0x000000000000000000000000000000a253a5cc517aeb5355cc507dd13c01649b", + "0x00000000000000000000000000000000000eabf0702aeaf3687ccd37f915963f", + "0x000000000000000000000000000000fa09d1c5b7334edd245ca1c7484751a146", + "0x0000000000000000000000000000000000033a29b33b42df47e072f419ecf1e1", + "0x00000000000000000000000000000068402cb3387e20873c21b5cecbed30ac29", + "0x000000000000000000000000000000000022ea12e03f4fa8be007cfcb236a03d", + "0x000000000000000000000000000000cdddbfa9418b836e50ea09d17406c31e06", + "0x00000000000000000000000000000000002562102f34b4da4a0dc0855981d4ba", + "0x0000000000000000000000000000003fd5d827771206a607d5dffa24cd8c6c4e", + "0x000000000000000000000000000000000022d89961636344dbfb64fc460c980c", + "0x000000000000000000000000000000131a487254d372667a99dc85be24e5cd03", + "0x0000000000000000000000000000000000047b2d5e54f8007f15c8b2fd5c82be", + "0x000000000000000000000000000000976cc58ccb66e097253acb1b3888102f6f", + "0x0000000000000000000000000000000000080c14817c4a9e6eef9dd6ab5d3c16", + "0x000000000000000000000000000000639bb53c2654d493ce5072d8fc2d4954f5", + "0x00000000000000000000000000000000000d85125a9036e1ae1c5a69fb52d3b9", + "0x000000000000000000000000000000f3021896070f4b365fa4fb244174eaa223", + "0x00000000000000000000000000000000000c0f086a0470ef314c720b950ef2ea", + "0x000000000000000000000000000000497578c03ad3935905cf61ca910c7331f5", + "0x0000000000000000000000000000000000002398ed1decdb3cfc47f7457c1174" ] - hash = "0x20ab775da5bb45344ffe17866237142b9321b97b2e93ccfb1c299476a262e0b5" + hash = "0x080a62f938a5f53f13c6f7f76c406722d810698e6354fed4f4e52ae528e124f5" [[inputs.previous_rollups]] proof = [ @@ -1230,21 +1268,21 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 [inputs.previous_rollups.public_inputs] num_txs = "0x0000000000000000000000000000000000000000000000000000000000000001" - out_hash = "0x009be21298b4428b38b9b314446eef3243121c400edd3780e34da475ea5f17c3" + out_hash = "0x00f329e671c45418c360ecaffc93fbda197fdbbb11c27c83ed0381ec4ff35ccb" accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants] - vk_tree_root = "0x11065543c9a42eac842466277ee9149b27403e398e94c6bba4f525931a2ac6bc" - protocol_contracts_hash = "0x24b2bd6e0456d2d2e64beb505010896a57017c6dedf7516d314d551720c3e6b4" + vk_tree_root = "0x1d51e7bb66dda198c072b182a8e4809fc6614d677c914af2afa9c5376f16f06d" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.constants.last_archive] - root = "0x26c404240cb9d3965fdd677de1d4ea1d907e460403e304ed198e839901a4cebc" + root = "0x22fb435f1b17b06f994e96f8b9092935bb52d7ff089f9da911deb76fb11eafd0" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [inputs.previous_rollups.public_inputs.constants.l1_to_l2_tree_snapshot] - root = "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" + root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.constants.global_variables] @@ -1265,75 +1303,75 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.start_tree_snapshots.note_hash_tree] -root = "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" +root = "0x144f9224dee4aac6eddc5d988e7c6965528d2e08db91cf58989655a68fbfcc52" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" [inputs.previous_rollups.public_inputs.start_tree_snapshots.nullifier_tree] -root = "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" +root = "0x191d19a6ad2b7bba03d122035938544f5e65de24aeaa436cd5e4d977bd014505" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000140" [inputs.previous_rollups.public_inputs.start_tree_snapshots.public_data_tree] -root = "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000fe" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollups.public_inputs.end_tree_snapshots.note_hash_tree] -root = "0x0058e56291a20ba5208dec6c4e6f93513a7e475709e9292d09b7ca1c7147703e" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" +root = "0x12a2218e991bfcb4acb2e3e5a91d8424043c127125a1705c50f526b657f1522d" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" [inputs.previous_rollups.public_inputs.end_tree_snapshots.nullifier_tree] -root = "0x06d941e09284387689272aef891ff6ec71993e808f3a832c4d1fd74955b1901e" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000140" +root = "0x05006c16ae34df049241a32f199ec71b6e91f581b27e4ae8da8d8658a93f4d46" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000180" [inputs.previous_rollups.public_inputs.end_tree_snapshots.public_data_tree] -root = "0x069ad5cd9f6b5ac53ec9533083d53fb0e3b8cc49b13211bd6d314c00493971c2" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000013d" +root = "0x18bab17c744c297c8a7ec8cac2c6f2f6c4b6b4041037f5e4dd97d04b37e2f026" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000fe" [inputs.previous_rollups.public_inputs.start_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a9d" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000eec" [inputs.previous_rollups.public_inputs.start_sponge_blob.sponge] cache = [ - "0x00000000000000000000000000000000000000000000000000000000b7e5c34d", - "0x00000000000000000000000000000000000000000000000000000000b7e5c34e", - "0x00000000000000000000000000000000000000000000000000000000b7e5c34c" + "0x00000000000000000000000000000000000000000000000000000000b7f9d44e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44d" ] state = [ - "0x0b7c9bbfac21d3c59031a865ee1f7abea9012d898a238d0b9d545e7e15be4f9a", - "0x11e47e7e5a97cace7b8cb5c63eeaf7cb076e5e19a4e89c1d3f4c3fb1faddf0b3", - "0x03a1357263e162410b5a70343adea4b373f3006660d9b40c28425be41749a8f7", - "0x100bc00d33720748142a7cd2ab57c5c140b681cdeec9b6197841f983ed05a3e2" + "0x2d2cd78abcdb723be782846e1ad64ae3ab9aa2260689da6ae7475677befc11c2", + "0x0250e73c2089d502af086b4d31fc90a61b62f71901e93588a19421c1e54417db", + "0x1225c74c7caef02691c6f3a18a18ed4ce10675ec8286339594bef2cee3bcdf01", + "0x0b9145803dfcf3b0958502feb867fdbb62eb5726361b0971f704ffe19719c0af" ] - cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" squeeze_mode = false [inputs.previous_rollups.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000fe8" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000001437" [inputs.previous_rollups.public_inputs.end_sponge_blob.sponge] cache = [ - "0x00000000000000000000000000000000000000000000000000000000b7f9d34e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34d" + "0x00000000000000000000000000000000000000000000000000000000b80de34c", + "0x00000000000000000000000000000000000000000000000000000000b80de34d", + "0x00000000000000000000000000000000000000000000000000000000b80de34e" ] state = [ - "0x22b79dec2cc8832eb6f5b6f555e3f46df7cf49c430792401c0bd69d93acd5a9e", - "0x11f095e238c4fcaf03e98bd59bc4ced15d15c960672b7985f115d431b6465f28", - "0x2fffb57d55f42b18f76eeac271cb09237dee47004c2003d367dd7f783837dbbe", - "0x0350c82eeb6f621178086345c4170033e27dd8ca1fd9fec9277096ac2a409fee" + "0x081ffd41f516611101fabed22dbbba6e6bf5ac0eff43aa020fb8407fe66471be", + "0x07e1027927852cc3291b4d5b979823dfacab903c13b5bd3f2590388210b608ed", + "0x17c059bfe7dca4a328bf27482e1c7d33887c0ff69b69f2be89eb754266e263ed", + "0x1e85bde3c04a4baa1d2d6e1237d10ced927e777bbd7fa7c31fce28cdd79b92ca" ] - cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000003" squeeze_mode = false [inputs.previous_rollups.vk_data] leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000008" sibling_path = [ - "0x20ab775da5bb45344ffe17866237142b9321b97b2e93ccfb1c299476a262e0b5", - "0x2a9ef81b082ec4212c08eba71c46e645efc1ae573e9cca5b480785be9dcc4d21", - "0x18b9d1703288fad007e0e97212dedf18305ab172790fe8d5c7aeea5c2634673b", - "0x0481dbd69f3e084904030eb9771134ae7be848ec7b4af69e75933270ceeb544d", - "0x1fe698f1a6368c855525a9abcc3713bb49b1dec627f796bf4e23cc86473621ec", - "0x1c7b07f7b3f8344fece2e6a10bc9480dc4b90f89d2a51f344bee80ca5a4bda6e", - "0x12ed8e93726f8b5b79d1291566a72c1775861d60bba2daa19edb3f28d0ae7a3e" + "0x10b6730f1d1e9c6bf8d7c4b42b64b40d2603e3ae6ddbd464c3d8fcfb9e06e6d4", + "0x014ffec160e37b6cb713c1a4e6e7058964dde1733e6734520ed72f72fd262919", + "0x14bb1983f28c88ab603e0fe7e46b743829816df364ec385e2245072c3dad3e1e", + "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd", + "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d", + "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", + "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd" ] [inputs.previous_rollups.vk_data.vk] @@ -1341,46 +1379,46 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x0000000000000000000000000000000000000000000000000000000000000017", "0x0000000000000000000000000000000000000000000000000000000000000042", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x0000000000000000000000000000001393476211d0127a80dce177bd2139b525", - "0x00000000000000000000000000000000000a64db7a774dad381e4034cb2457f3", - "0x000000000000000000000000000000d5fb425ef17d829bcbd2f2212397cc69ba", - "0x00000000000000000000000000000000002902ad5d5e880ce9d3ff8815ad1554", - "0x0000000000000000000000000000009b94b4b71ebf49ca1ccee622099eb37a96", - "0x0000000000000000000000000000000000217517f2a6d3c0ad2a63c69b28d392", - "0x00000000000000000000000000000038d8df60934ce84e0ed3e7f5ca09c1ee4d", - "0x000000000000000000000000000000000013384c8161e64209078ece69fcaa19", - "0x00000000000000000000000000000093c2a0c6ec49f39474bd6782c5cd6b01b2", - "0x000000000000000000000000000000000008ff5813561afc758759d27f19b55c", - "0x00000000000000000000000000000097291956465f3aa94d25b11bc567a6c287", - "0x000000000000000000000000000000000007f14a03af147b21368785d869ca98", - "0x0000000000000000000000000000006a811b91c5970c9c2acd7a754d7b7f9cb1", - "0x0000000000000000000000000000000000190a1ac15c24fdafc83b205b9a284b", - "0x000000000000000000000000000000b61bdc9c40c5c1e94e290d7b383b2ee122", - "0x00000000000000000000000000000000002f5117ca48de83b07881d30427d341", - "0x00000000000000000000000000000012095bbac1cead43059d0a230818a027b7", - "0x00000000000000000000000000000000001c7b3a018ad17b7cbb3752d56c6f80", - "0x00000000000000000000000000000018c18cff602c8434b90273cb1ff38dd751", - "0x000000000000000000000000000000000003bd5bfa0c05c005fcbde355422947", - "0x0000000000000000000000000000009dac7aa803151cb1966b812422755d8e9e", - "0x000000000000000000000000000000000010f818617b14b429abcd3acd46653c", - "0x0000000000000000000000000000007951c87d59a7b4319ddc32a19635675d94", - "0x000000000000000000000000000000000005be6b96d6eb897429b815388db99b", - "0x000000000000000000000000000000d7e7c851d3ba4e42b00b50dcb9a40159ff", - "0x00000000000000000000000000000000002750be703cf6981c927c48de088588", - "0x00000000000000000000000000000048b23b4fb077032ac487b882dec8a8c38b", - "0x000000000000000000000000000000000017150b214b8aa285fed8a5b374a4f9", - "0x000000000000000000000000000000416e099bfce67a459c5a20a4311705f6c4", - "0x00000000000000000000000000000000002b684b94d2f1f96e86dfad7af6171d", - "0x000000000000000000000000000000651160cf941fb73a15062e12bfc9e35804", - "0x000000000000000000000000000000000007a1bb9d8533d71515e6e3b5e6866d", + "0x000000000000000000000000000000ed9a7d2d4e3143f585e5d95ca0088bd58c", + "0x000000000000000000000000000000000017f0f4eaca0b57f0254c56d1dcedf7", + "0x000000000000000000000000000000ecccc921a1dbc3116699315b30064501dd", + "0x000000000000000000000000000000000007fad76ddbb6ce8aaca29ac003544c", + "0x000000000000000000000000000000a58f237d5e3447619bd4995b6ab57329f1", + "0x00000000000000000000000000000000002e515ae24d7f583b5f5100e24e3a7d", + "0x000000000000000000000000000000c609b48ceeef44433a6570619898618e60", + "0x000000000000000000000000000000000021d92d4fc9578a1a92cadfd56bac1e", + "0x000000000000000000000000000000b9399d03a2bfe064a77805cd6299a18123", + "0x00000000000000000000000000000000000db15007f51cf45f0d4b5d0c72323f", + "0x0000000000000000000000000000002a813d4b748008a99d0bd98951733eecaa", + "0x00000000000000000000000000000000000006073a97f000f318cf4a87829a35", + "0x000000000000000000000000000000668d42870be7a506027fe80fdc5dd724aa", + "0x0000000000000000000000000000000000280e58b7658c0def5e89405371531f", + "0x000000000000000000000000000000748c0c2a74f8b51f4be7e8609a786d38fb", + "0x000000000000000000000000000000000007c3968791160ba6c2797f72cd485c", + "0x000000000000000000000000000000c047c85668bc7b41958055de15710dffb0", + "0x00000000000000000000000000000000001d09d1eb7e5a7fe0f1ae561fb471a5", + "0x000000000000000000000000000000ad226461b40c2b3ce2ce71eb9b3489b875", + "0x000000000000000000000000000000000028f73ffcd9c4f10b332da3c4202321", + "0x00000000000000000000000000000081bb4666343407adfaf6483652850334e8", + "0x00000000000000000000000000000000001904e26bb7deea88b240fd9f64d6c2", + "0x000000000000000000000000000000046a09098559eb29059aaec545f1b60ab4", + "0x00000000000000000000000000000000002eba2495a17bb6751670d141eba5bc", + "0x0000000000000000000000000000006d4c6812176142054ef8b72fcec9ab1d46", + "0x00000000000000000000000000000000002f17523cebbe0a959a3d3ad4008621", + "0x000000000000000000000000000000fea01dc8a40e8358627aefbdc809f0d16b", + "0x0000000000000000000000000000000000255b95149080440a22c012db52d174", + "0x000000000000000000000000000000b5e6e229f22d5d6130b6940f897bd687ad", + "0x000000000000000000000000000000000002c1d364ecb3f8b13d39b364b9fa17", + "0x0000000000000000000000000000000ace98195a1e28904eeb54e8f1beab8965", + "0x000000000000000000000000000000000021ddb285f5b40df25978b16f38fa55", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x000000000000000000000000000000bada1572761d2d57e5d206da78afa472c5", - "0x00000000000000000000000000000000000248453a876b49502a5a8259818f44", - "0x000000000000000000000000000000ec45f0511c4ef04800c3d31e152e9265de", - "0x00000000000000000000000000000000001fff1bef8afe963c3b78c3c2549ca4", + "0x0000000000000000000000000000009723288bf6b623aceeea91e62d1533d690", + "0x0000000000000000000000000000000000015e128393cc29fc38e815d2a2c8bb", + "0x00000000000000000000000000000034f5a0b8bdc854f056ab93f34153f52607", + "0x0000000000000000000000000000000000239dafd7ff901c78c54dac6ef232c4", "0x0000000000000000000000000000006f206a04895661d3bd004222a1f8a7fc73", "0x00000000000000000000000000000000001b12a59a820d3aa543a594a1b9d92f", "0x0000000000000000000000000000002103559842aca1e08af33bb1f714ebc02a", @@ -1401,57 +1439,1109 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x000000000000000000000000000000000021a0543de0bc42d6586454ec8b623b", "0x00000000000000000000000000000016bf0724359c9a09ceffdc9371a2d6e5dc", "0x00000000000000000000000000000000002fd4c13c6f5523a7f44b28ce3d342a", - "0x000000000000000000000000000000e379faf5ffdd383be5ce0f1ee38f5e73fe", - "0x00000000000000000000000000000000001429616496865cd170bc83c40d415a", - "0x00000000000000000000000000000066e08b7ad48415290d2ff590e84057e60e", - "0x000000000000000000000000000000000023a625e90ae9701e33c52be8f0d396", - "0x000000000000000000000000000000774fc954a6adaa4e4db1da6228184e1354", - "0x000000000000000000000000000000000015ca4073735e39fd5dc55567dc1068", - "0x000000000000000000000000000000fd9e5f594db01e4b2625e1e3dcfd400f6e", - "0x00000000000000000000000000000000000f4a392bbee96bddd468b2c9a18896", - "0x000000000000000000000000000000d28954aef28e666d63ee0fb401ab7bc1b6", - "0x0000000000000000000000000000000000253b48f95132d1a3183e26dbd56884", - "0x00000000000000000000000000000022887784410bf17c157fc004401281c342", - "0x00000000000000000000000000000000000a249d88427c50df84670228613493", - "0x0000000000000000000000000000000f495c15c8a9098c779fef9227f1c5a897", - "0x000000000000000000000000000000000016d74e40a54fe1961a01c0a275941e", - "0x000000000000000000000000000000a968320348365b69bc59ded07a855fb88c", - "0x000000000000000000000000000000000010c9846c3754b0fb4b4c9ab8d68cd3", - "0x00000000000000000000000000000088ee0f0a54893f8b1e8b56a7fa7bee9d4f", - "0x000000000000000000000000000000000021d14db4aa9ae9f88641b9336d9dba", - "0x0000000000000000000000000000000f46a800020405196bda0c07afe5154eac", - "0x0000000000000000000000000000000000062e98c038c271784c9fb61136242f", - "0x00000000000000000000000000000024ed87f3417bd5bbaa53682680b1b915c8", - "0x000000000000000000000000000000000003beb3d385de2c0a7a40cebe01d34a", - "0x000000000000000000000000000000f85b812b32412267c5221f3600eaa3f3d2", - "0x00000000000000000000000000000000000289ace5de4f3e7a721b5a184d1e76", - "0x0000000000000000000000000000002e30085e1c74fe70d1d2ab68faf0984ca4", - "0x00000000000000000000000000000000001adb7660db50eb3c9d70b137871b2f", - "0x0000000000000000000000000000008e05ae370a270eeb6d282e3bc2b7889cc3", - "0x000000000000000000000000000000000020e76f33b00bccd1f97095bece663a", - "0x000000000000000000000000000000d71d8a40f7c9f1984d513aa7eb1a895e6e", - "0x0000000000000000000000000000000000021aee4d83119d0af331d5893af9fe", - "0x000000000000000000000000000000dec3abe29c9aa4bf73251a0c748d11e9dc", - "0x0000000000000000000000000000000000153c1ed58f5394ad372869f471ca8b", - "0x000000000000000000000000000000bf4d6e6ed9dad1b05bd3d5cb3b3740d3e2", - "0x000000000000000000000000000000000006803b1ef715809ab5085220b7c284", - "0x00000000000000000000000000000041efece86e20c4323fb08d7aad7345c79c", - "0x0000000000000000000000000000000000096fab6acc87fe26e0eefb5660a7db", - "0x0000000000000000000000000000002d550983acbdea743f381bf4d55b8c6110", - "0x0000000000000000000000000000000000107455727dcf49837ee29622f4e9ae", - "0x000000000000000000000000000000a07bfb26d2f33a45866564f6fb630fc1b3", - "0x000000000000000000000000000000000004b58a9a3d784d5857e224b300b97a", - "0x000000000000000000000000000000c0f8d7d2fa6eac6b45b736e838db02e437", - "0x0000000000000000000000000000000000012728fef15749f6355802ac76d166", - "0x000000000000000000000000000000caa9dd21f786e491093e94a42326c20c4b", - "0x0000000000000000000000000000000000181c00a5273565ed45cde6516b7267", - "0x000000000000000000000000000000f791b0a7d2376523eebf266bd58c615a72", - "0x00000000000000000000000000000000001658c7b51e5eb76e58124a4bf26d30", - "0x0000000000000000000000000000007ffefc9b69f9b9f766f98d9390ad49a8f6", - "0x00000000000000000000000000000000002700900f023bdb2524f5ce218af8a6", - "0x0000000000000000000000000000001d12e2e9feedc5df84ac9cb8e405fc64ea", - "0x00000000000000000000000000000000001645d7c72fd8844ddf0659d2b77656", - "0x00000000000000000000000000000098eaadb9c8f156e98d8dfde6f90be22a80", - "0x000000000000000000000000000000000028291c89dafd88dced57d87f6d8ab7" + "0x000000000000000000000000000000983b80f553a1f41ea4a613c4272296aa6a", + "0x00000000000000000000000000000000000fad2d11baaeba59740ea2e1e556ab", + "0x0000000000000000000000000000000df8dad25aabadfb2fd689e927f28e9905", + "0x000000000000000000000000000000000006e77d6620186fb40fa775055f6e02", + "0x000000000000000000000000000000ab530a3e0bd1b4d58d3462aaa5248378ec", + "0x00000000000000000000000000000000002128bebd2165991c478744366c2660", + "0x00000000000000000000000000000069959e29b21942c9bc6095c81c52e09e2e", + "0x000000000000000000000000000000000029521e97be7f1262547599981f9dfc", + "0x0000000000000000000000000000004b83cde93267991f2e75cb58d8c62fc648", + "0x000000000000000000000000000000000024bda0836d4ea3d2e8d16bb8b929ff", + "0x00000000000000000000000000000039b6192602f956e962d51c4dbe711e46b9", + "0x00000000000000000000000000000000002b58de5dca4604474742cc42f7a05c", + "0x000000000000000000000000000000dc0d4adfc6bbc96e9863eef8920e82c85c", + "0x00000000000000000000000000000000001c791e40bb700a33ba6343f2d60474", + "0x000000000000000000000000000000213ba680b5b07b331f0153faf572881700", + "0x00000000000000000000000000000000000d2a671fdcd41097454dedb403cf28", + "0x000000000000000000000000000000c40c6f11a42754888c5d0cac2acc5c2e99", + "0x00000000000000000000000000000000001f95faca5af29481f878207f1f3461", + "0x000000000000000000000000000000af74c82994a772d5816d23cad77f507de0", + "0x0000000000000000000000000000000000298a0a94c391ad23bd2714cd83d85b", + "0x000000000000000000000000000000f118536b214a0b173d683952cb179f7308", + "0x00000000000000000000000000000000002048287f58cbf84bd0bdaa216b750b", + "0x0000000000000000000000000000008b7b9a9326671e5fbe01204632efe954cf", + "0x000000000000000000000000000000000000e6e717ef9fe95faf3dc3c94585c0", + "0x0000000000000000000000000000003d73274d5823c057df53030584e69fb7df", + "0x00000000000000000000000000000000001197cce7dac8be65e92fadb47c7e53", + "0x00000000000000000000000000000075d310ff38e2775418a123dcca24d43741", + "0x00000000000000000000000000000000000ca18eff9b17d5e1a103b5c931c576", + "0x00000000000000000000000000000031323a2499d3b128f28b1305246959409a", + "0x00000000000000000000000000000000001dd443e2b9f240a6f8b9b4e29987d3", + "0x00000000000000000000000000000050fea0738e4ca6015860a1370ea49b70a7", + "0x000000000000000000000000000000000017bce74645c162884adc4a6fb7a907", + "0x0000000000000000000000000000007b57ed2a44bfcffc4fc896d15c31ad0d1b", + "0x00000000000000000000000000000000001e4d34edb06ee6ba520d1db5080d9c", + "0x000000000000000000000000000000db1a4b059c0f5fe3e9df6ff8e0d192aca3", + "0x00000000000000000000000000000000001a05c7210c56b6bcd1dc18cff662d9", + "0x000000000000000000000000000000e67e3c5e07fbdd021dcf504db8c63d9b7c", + "0x0000000000000000000000000000000000252935e626c53fe844eb3b48575177", + "0x000000000000000000000000000000c2b7a9a8d8d31df906bb3d90342b9deb2e", + "0x0000000000000000000000000000000000090be4375322103f7233fe4dc9aefe", + "0x000000000000000000000000000000ef6397346da2082caf01b01d285e62e79a", + "0x00000000000000000000000000000000002e6d903371b2347a7cee9a53b3ff86", + "0x000000000000000000000000000000c121fa0e4904211f7d8bd7bed351379d29", + "0x00000000000000000000000000000000002a144c122f68e5b0b50412e6c3341b", + "0x0000000000000000000000000000003cc64d54b35537185ca0399b5e8103b296", + "0x000000000000000000000000000000000004ab8b6bb82552fccc8b2d8b078787", + "0x000000000000000000000000000000d679c88a95d67824fb6cd1be11125f4134", + "0x000000000000000000000000000000000001406dc68a75534a42bc313b9789a6", + "0x0000000000000000000000000000007f458ba267d25862d28eead635c9f44260", + "0x0000000000000000000000000000000000176c2fa161d670836afa9958b8ee4b", + "0x0000000000000000000000000000003ba1cc971819aacf0bcb421bd3aead9f0c", + "0x00000000000000000000000000000000000366f6e08da4f6c87b3393784388b0" +] + hash = "0x2597d0ee94af6c241e63bc541fabe57e418d679cdeb426bc76fe81a01487c4c0" + + [inputs.message_bundle] + messages = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000000" + num_real_msgs = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.previous_l1_to_l2] + root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.start_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.start_msg_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" +] + state = [ + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" ] - hash = "0x016a3b94e0b04a9f99ca3c31a475b4b5b1854bb2f3cea14fc49177110c9d7142" + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-merge/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-merge/Prover.toml index aed9ec3e1772..2a77a9e7c538 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-merge/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-merge/Prover.toml @@ -483,8 +483,10 @@ proof = [ ] [inputs.previous_rollups.public_inputs] + start_inbox_rolling_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" + end_inbox_rolling_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" checkpoint_header_hashes = [ - "0x003f28245501cd83312b059b7469c9efcbd17cdf1b87748a6684380140e8b8f4", + "0x0075a0954c3f9e7800b009595d7c46b310bfa9aae2fbc69756818221e6383e7e", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -519,33 +521,33 @@ proof = [ ] [inputs.previous_rollups.public_inputs.constants] - chain_id = "0x0000000000000000000000000000000000000000000000000000000000007a69" - version = "0x000000000000000000000000000000000000000000000000000000005fe47cc3" - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - protocol_contracts_hash = "0x080e3881bdd4a4e78d52691e5543b50cf820f51baf52af42d7b58c9e15f96ec7" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" + chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + version = "0x0000000000000000000000000000000000000000000000000000000000000000" + vk_tree_root = "0x21cd94941458effa5bf748eb3839418d3deb6bdcd2c04148ca733561265326a5" + protocol_contracts_hash = "0x0a1f22b72996215e178699fff463a6ca5e3c7d5ffe66e183490eb766ec1c83ae" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.previous_archive] - root = "0x1842a814b068f699565f4df77ab9139f1cfab687ef959bf92ba0bb3adf93d8dd" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000009" + root = "0x0fb2945d3438d906d88a216364dbfe9760e96001343468610e01d18182d493d0" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [inputs.previous_rollups.public_inputs.new_archive] - root = "0x1302274e4a6bea5811bcdf1a547430241566bcecab5eb026ced46711d8e78501" - next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000a" + root = "0x02b050244b9b298112dc7ce705838f55beca1ba7747d34532f285660519c21a6" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [inputs.previous_rollups.public_inputs.previous_out_hash] root = "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.new_out_hash] - root = "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093" + root = "0x0003e0e323f66d29e6a69f447a88e682190ce3e0a2546cb3e7f4a3ee4a31f1f8" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [[inputs.previous_rollups.public_inputs.fees]] - value = "0x00000000000000000000000000000000000000000000000000198e45581dc500" + value = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.fees.recipient] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [[inputs.previous_rollups.public_inputs.fees]] value = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -772,15 +774,15 @@ proof = [ ] [inputs.previous_rollups.public_inputs.end_blob_accumulator] - blob_commitments_hash_acc = "0x00c7d69903605c24450d8cc4111d6b01e31f84cacd7a01402f0cef9f221f27f3" - z_acc = "0x1beeba27d94c66514c35883c6684bfdc767455041a16225205c326fd2e2cb7fc" - gamma_acc = "0x088bb68a165bc27058fd98272ebe5f98cb66378ebc3d5c2639d6f59a66e134ca" + blob_commitments_hash_acc = "0x00c52b72f554c05bf88d89c15b72dfe195c63faae292a2545603eaf2b7c4b179" + z_acc = "0x166af4d9536b4efc740544b393d04d0954d9c9f2e1a920e767d82c840a9ed746" + gamma_acc = "0x292bd05c3e9242b3c86b92c09c6ee6122bd52c3bf36f974011135ffdf833d2b2" [inputs.previous_rollups.public_inputs.end_blob_accumulator.y_acc] limbs = [ - "0x523fafae630b01cb88597856ec2ecc", - "0xf3db7c5d601e16ac93c5bbe54e70b7", - "0x31dc" + "0x2d0c8b1b37f5517da8437bbcbe12ca", + "0x47f9a79dce520c34f6ca66890c7b63", + "0x10e5" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc] @@ -788,168 +790,168 @@ proof = [ [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc.x] limbs = [ - "0xdc0744575b26b4c4b7ee41dc7bee5a", - "0xab24ae0f1c266615b22dc3e9ffeecf", - "0xb738f18d636a06615561d266fd2d4d", - "0x19668e" + "0x9c080119e839655e99a11674011585", + "0x443513dc6fc3022a076e3e952493f9", + "0xa7c1b04b9b00d9dcb9541ef3a85eb1", + "0x16b0b9" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc.y] limbs = [ - "0x713d223616e8efe8cd4821efdde4f2", - "0x9a9a221be261841a9296b4d1eefd77", - "0xdb1af24cb0ccdcba1a7900c4fc1ad5", - "0x15b665" + "0xd77f761e6787b524a176983ef5b282", + "0xd76279f520567e299f71b8309d68a6", + "0x5eb62a7b495df2bb3ba3f3fcf8ad34", + "0x018120" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.gamma_pow_acc] limbs = [ - "0x3091f45075ebc6c0e8bd0d0b55148a", - "0xba36f4511ca8e170b8a14a64a7418f", - "0x070d" + "0xf940154dc87997c7e9369e713db21a", + "0xdb732975b8d0f86074d187d4b1d3ca", + "0x1364" ] [inputs.previous_rollups.public_inputs.final_blob_challenges] - z = "0x1fdc12adc29013642cd3e65ed4fe6257a51f0de3dbf9aab308d2eb764d2e2a6c" + z = "0x01d061ec599485ae8e2d63571790851cb49e4f2e838ca555550b4c3724750a50" [inputs.previous_rollups.public_inputs.final_blob_challenges.gamma] limbs = [ - "0x3091f45075ebc6c0e8bd0d0b55148a", - "0xba36f4511ca8e170b8a14a64a7418f", - "0x070d" + "0xf940154dc87997c7e9369e713db21a", + "0xdb732975b8d0f86074d187d4b1d3ca", + "0x1364" ] [inputs.previous_rollups.vk_data] leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000011" sibling_path = [ - "0x233055a6920a13764c09bad668c75e48f8165a1894c37152ede5c09640a63b15", - "0x2c74d12f23eca40b1748248d689d41cb7ac4771cecfe01c3ae67dab27f821949", - "0x035c573a1f2634405482213a2b805e186d6b81073e2b7a5bd3f64c2e4e8bc21e", - "0x033c4d295fe10d44c10ab7dd6b98731454b30ab8a3b175477338750c07bc4023", - "0x234c347546637311dad66534e5274a6a5db5da51b51baab040dac88807024ce5", - "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" + "0x0c10eb598741660f2160b4a6fe77191ad0c218b3a5f0ec4b8ebfecffaec4e4b9", + "0x121157fe0e38fc9db652bd52835686237090ef182f269df6fe777c5e5fd48aad", + "0x2e786d2377d9994a6dab998e113d87924b5b55a476ff385d0c66bcbb91158c60", + "0x20738d93e695096c6290e7c275252b87c3fc8a419bd4d9991368484bcbd446a7", + "0x2ea23c9cbeafe466f3725ea750741efad48745849cf61628cb3cd0e6156c6246", + "0x187a7b8872d1297bc15f7171f32c36e5e60b53c4145ef62b1899c04fd7220fdf", + "0x2ccaede67145021b6b586f45936dfbdacb151c3e362621c3598ffd60e95b02a0" ] [inputs.previous_rollups.vk_data.vk] key = [ "0x0000000000000000000000000000000000000000000000000000000000000017", - "0x00000000000000000000000000000000000000000000000000000000000000a3", + "0x00000000000000000000000000000000000000000000000000000000000000a5", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x000000000000000000000000000000744c51f21e3dd8540bccf510ecc1d766be", - "0x00000000000000000000000000000000001e95a14c474168aaa5c9372f7a0abf", - "0x000000000000000000000000000000879082cb89dbf870ad3aa0d5da2ee67125", - "0x0000000000000000000000000000000000192656445ad3e71909ee40b06deeaf", - "0x000000000000000000000000000000e1909fba28938423134c0d59b76683863d", - "0x0000000000000000000000000000000000003e26f42f57c6e694c1e7e40b17c6", - "0x0000000000000000000000000000002a188fa67065c4bcc359cb5fd771dabcb6", - "0x0000000000000000000000000000000000160ac0b054344bb77bac08ac568575", - "0x000000000000000000000000000000fc970af33d774376cf02d202aaef414ba5", - "0x000000000000000000000000000000000021c2bd629cd0a533238d0ab831f778", - "0x00000000000000000000000000000068db97499ceb5bc0ee7a25f7b9474f2b8d", - "0x0000000000000000000000000000000000177f1d3bcc53dc664aeffa8f221982", - "0x00000000000000000000000000000071bf5b67b8cc7197d679fb2c9b28eff994", - "0x000000000000000000000000000000000004d0af735c0dba71607923878247b9", - "0x000000000000000000000000000000f9dfca16db1889889cabadcb3c086a4f27", - "0x000000000000000000000000000000000000ab2307518eeb29981848b3d1ee07", - "0x000000000000000000000000000000d6bffac49573916cfa0c7fc812ecbba5b6", - "0x000000000000000000000000000000000009655ac19e9e344b05e4a2fdce84c7", - "0x000000000000000000000000000000f7755de133f87eac380cca4fb5d60afa6f", - "0x00000000000000000000000000000000001d7cff28580bdd7cfbc17f159c5620", - "0x0000000000000000000000000000007f26c16746a68d8270726a65373e58c426", - "0x00000000000000000000000000000000001bcc461c1faa451fd1a0ed4683c3c0", - "0x000000000000000000000000000000ae6f4726a6e0f83357befc61e67a9ca001", - "0x00000000000000000000000000000000001ef4f7456ae1908e7a90de3d05cff2", - "0x00000000000000000000000000000017d5cef864c8bae29b2bec7712603477e6", - "0x00000000000000000000000000000000000c2947db29055b93c4ab5b26120a74", - "0x0000000000000000000000000000003a28bc16570b9a581942c4f4a5978e6455", - "0x0000000000000000000000000000000000297af63688110e42582a51c7fce3a5", - "0x0000000000000000000000000000008de422f0c439a79c6fe60b90f08dfe1498", - "0x00000000000000000000000000000000001c56ba82c1f1910eb581559e94ae3c", - "0x0000000000000000000000000000006fa0127d67c2462bec9945343f82c18b62", - "0x00000000000000000000000000000000001ab9b001ba47aa775c9094ccff2543", + "0x0000000000000000000000000000003288730860744d90f8dcdc13940fc8d87e", + "0x00000000000000000000000000000000001a6480ae73e5d86fc292b430b8a751", + "0x0000000000000000000000000000006917a325f36c3d0079ea3a8a3f1163f738", + "0x0000000000000000000000000000000000040b3b47fc35b7e61722173a8585ca", + "0x000000000000000000000000000000bd731678729bd1076face8dda8d5fdd33e", + "0x000000000000000000000000000000000010d5115052c7b5d12f7f7fd39c73b1", + "0x000000000000000000000000000000143cbf9cb288d55c919de0d3c6b5f418d8", + "0x000000000000000000000000000000000017dbc3182e0956e2ed401eabcc8f94", + "0x00000000000000000000000000000079c549a08f8e493ac82a3298d5020166a1", + "0x00000000000000000000000000000000000f15af4534a6f141858cc1ea55d87c", + "0x0000000000000000000000000000000d5ecf557d36b122ff3d2384ed60de9d98", + "0x000000000000000000000000000000000008816a47846bc89240d2e13c362be1", + "0x000000000000000000000000000000e315f3df73d78bae1d02fa60b3a7a3ec68", + "0x0000000000000000000000000000000000093e3211a055f01f562492428baea9", + "0x00000000000000000000000000000027ebb9883a8e78bd492c14bd0cb85a6e19", + "0x00000000000000000000000000000000001b7795648f8c1f9c520a9f842dc5be", + "0x00000000000000000000000000000035a06493c8f34e1fae3efa0c4c3d529858", + "0x00000000000000000000000000000000002456fd877795105f730069fc1fb9ef", + "0x000000000000000000000000000000c30ebb23e62d30c6a395834e91224c7111", + "0x000000000000000000000000000000000028e695b7da8c77dc517e5e3cc3c28d", + "0x0000000000000000000000000000006720355f00860876fb20c803fcddcf9b4e", + "0x00000000000000000000000000000000000ab7e9481137a97e36d8ced967c1ed", + "0x000000000000000000000000000000fcc8b48bedce5374db954ff6d9d4e5d59a", + "0x00000000000000000000000000000000001134dbc1b6735b7ebc219367c7cbbc", + "0x000000000000000000000000000000dd98d271d4d16e66d61039d006fdb08dd2", + "0x00000000000000000000000000000000002646eb78d367e3ddae2ee29657e78f", + "0x0000000000000000000000000000006e859a711aa7352e651b1b48330125a03a", + "0x000000000000000000000000000000000021784c3d16da5e715233b84c49fe1b", + "0x000000000000000000000000000000d4eed6e91e831b6232254e64a82fa8d212", + "0x00000000000000000000000000000000000b106a845234acad6cfaffc55cf2ff", + "0x0000000000000000000000000000005194ac5554bc31446a2822c2a90ee5d536", + "0x00000000000000000000000000000000001a0209e186160b00c1d9f45845ad40", + "0x000000000000000000000000000000513eaa372ee3ab77c56296538ca4437f01", + "0x000000000000000000000000000000000017aa55310d97d1bef2ce1f2a2e58f5", + "0x000000000000000000000000000000547582ffb04f9f2dc83dc8dd4ac9353afa", + "0x000000000000000000000000000000000009f0c660d3c44b7d47f82eae5c6e37", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000006691d9edd4281b4d8c7bfe7cf2114dbed0", + "0x00000000000000000000000000000000002f785826e92b236b3f40d64938a8af", + "0x0000000000000000000000000000001f2e233e205ebb1de17e51bd42bd2a6709", + "0x0000000000000000000000000000000000244972df89429a8780722959797160", + "0x000000000000000000000000000000a08687feb5bb3bbe8fa68abee82250cf45", + "0x00000000000000000000000000000000002b5b8e1d2121016a592d83cddf49fa", + "0x000000000000000000000000000000bc66f21b8eed9da44989f70a272822b6f7", + "0x000000000000000000000000000000000023bccb8cecf793ebbb1bda19fd1490", + "0x00000000000000000000000000000062017a22ba729a464723c1312a7b69c9bc", + "0x00000000000000000000000000000000001dac218f0b46fda3d521146527e842", + "0x000000000000000000000000000000ca406376e1831ce97513fe24aeed962561", + "0x0000000000000000000000000000000000294fc4df9082aa7fd5b670738928ec", + "0x0000000000000000000000000000008b9b647e54171de19e0b6f93ef5e48ac1b", + "0x00000000000000000000000000000000000f9038e596e4bc37a8636a2d461327", + "0x0000000000000000000000000000009f1ce1c28c8577cfc8339465e9d8f5b742", + "0x00000000000000000000000000000000001309f9dda0064b07081016e15d07ad", + "0x00000000000000000000000000000024222df0aa0ffa760557d17021c98eece7", + "0x00000000000000000000000000000000001d15b2767580e54d9ea596a65c9523", + "0x000000000000000000000000000000df15a11026f7fac6f9d648764a34019e0f", + "0x00000000000000000000000000000000002ce785169d9a643bb94c4af25cd196", + "0x000000000000000000000000000000308adcca358d6672a7b1866c24db257984", + "0x0000000000000000000000000000000000125b3d6f343c08e90f7a5c5e9d1711", + "0x000000000000000000000000000000e5dfaa669b75a8b832f3ae92f41a676f75", + "0x0000000000000000000000000000000000130e53472be61d363fe04154c25ad8", + "0x000000000000000000000000000000b77240211fc58c69db333948fec925ae5b", + "0x00000000000000000000000000000000000885c9c1fa31d3e07be8a05b37c862", + "0x0000000000000000000000000000003e1988529ef3e8c0f71d3bb9c5eabb0c93", + "0x00000000000000000000000000000000002f259eb9cf86aa730d5fd3307582c7", + "0x000000000000000000000000000000ff9c398f86a183fcbc41c36d7ea5486f44", + "0x00000000000000000000000000000000001d741554ae0921d8439277b831b59f", + "0x00000000000000000000000000000072f4ba06e6c859cafd74b8be78f4e6c290", + "0x000000000000000000000000000000000013c4ca91ce5c6256578e79b70a67f0", + "0x0000000000000000000000000000000dd655425a18bf1b28d418c22e417aed28", + "0x0000000000000000000000000000000000020fc7fbb26d277c22bd7780447291", + "0x000000000000000000000000000000ffb9ad1af1a082c77b4e0810594467c569", + "0x000000000000000000000000000000000020aa42c226d5a0970630ddbb783f38", + "0x000000000000000000000000000000bf3e76d8f3f21653422411fcd9a2bd5ae0", + "0x0000000000000000000000000000000000187d106d31fd0f38d51f99eab75ce7", + "0x000000000000000000000000000000cbf23559d5b4a16dc60742408bc4d980c8", + "0x00000000000000000000000000000000001fd1cc7837e440e779a50f76b58a2e", + "0x000000000000000000000000000000eb62206940246d32198b3141bc6a50abac", + "0x0000000000000000000000000000000000037f231e8cd28f0f8ad3cb5f466032", + "0x000000000000000000000000000000efc0ca88f857d42b88ac1ac92d9374b62d", + "0x00000000000000000000000000000000001fd02630798bd4633975daf091b593", + "0x000000000000000000000000000000da2f92a05047e7e8b1a822549759808b83", + "0x000000000000000000000000000000000001084dd81798c00eeb2887f2df9620", + "0x00000000000000000000000000000011fc26a27e002528f461224894ccd240ee", + "0x00000000000000000000000000000000001534fa0d9bbd25eba2f122eaad06bc", + "0x0000000000000000000000000000009f3672e356e98b3a7a3deae61a9b87dd29", + "0x0000000000000000000000000000000000301cc7d23879687ec5cbdc195436f9", + "0x00000000000000000000000000000023885c7bce9e0d10196c6f831bf4b229de", + "0x00000000000000000000000000000000001602ff1fe4f4cb70c26ad5bc16858a", + "0x000000000000000000000000000000fcf2a0c1eceb385200a0ee09c40c758fbf", + "0x0000000000000000000000000000000000253b9dd23a0982e9db87324acd9aba", + "0x00000000000000000000000000000097a1599a0f5c04ef46d89bc4be8629ed3f", + "0x00000000000000000000000000000000002ef5dbc090a304ab4d948f1e08a8de", + "0x000000000000000000000000000000691acea534b501c5d7a5984cbb56e2f677", + "0x0000000000000000000000000000000000256377fe9f1696e2316a0ede70e194", + "0x000000000000000000000000000000b1d93380e5a238c52f4d9327b8ff615f45", + "0x0000000000000000000000000000000000029f05bf11aee014fc3ca870e42dc7", + "0x00000000000000000000000000000083f400e03505d6e2e6a8d315ec5b24f54c", + "0x00000000000000000000000000000000000c031249619645a60ab26bf3069331", + "0x0000000000000000000000000000006e7016f5ace833e2821d171ef0fe2b9f8d", + "0x00000000000000000000000000000000000f8b062a1227fc7a323aed56615912", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x0000000000000000000000000000001aafcb2e2c5b4ee357c3cf460fa8614ed8", - "0x00000000000000000000000000000000000d7a76e33e068c44cecba8c22ae8d7", - "0x000000000000000000000000000000492fb683c7e0e137bc4e2ea86c37740b5c", - "0x0000000000000000000000000000000000206f337fb8b6d365b941ba4a8d8a9c", - "0x000000000000000000000000000000577c33d5c10b485d8c213d16ac4664dd62", - "0x00000000000000000000000000000000001dbb32af825db919015b2f62ac527a", - "0x0000000000000000000000000000004089798ec9503f6d851e3f36c8134fffca", - "0x0000000000000000000000000000000000258c2a8625473699411a82c908b205", - "0x00000000000000000000000000000039e66e47fbf20c042e57bc7b20b446fef5", - "0x00000000000000000000000000000000001a7afcba66a6d1561b93bbc1af74f6", - "0x0000000000000000000000000000002455981c887b06eaa76d3e33d58c191122", - "0x00000000000000000000000000000000001de23e2477dda30d3d197f197ac419", - "0x000000000000000000000000000000b116578da6236d15e82788782d873df37f", - "0x0000000000000000000000000000000000269873dc9e65f74c789d8a58db0077", - "0x000000000000000000000000000000ee7cf9691c5ad6f6e90099bc5d04408a73", - "0x0000000000000000000000000000000000284704a1b995c3a251204d4c6c01a2", - "0x0000000000000000000000000000004d63dd4c7af54fcf2e481be7293211350b", - "0x000000000000000000000000000000000003805c1292ab954706ed7e0cca9281", - "0x0000000000000000000000000000006572fd92d3bf1845cceeef0a7f0d044f8b", - "0x00000000000000000000000000000000000641fb756d60be4b60f5c0a76f6930", - "0x0000000000000000000000000000003c9242ea4df53612f2943b641741fb9359", - "0x00000000000000000000000000000000002ebb3334e2b6b702d04d94e2c6a5c4", - "0x0000000000000000000000000000004be64b431a5a816b719da16e8e02535892", - "0x000000000000000000000000000000000001339afc1567176d3527faaf56c0a0", - "0x000000000000000000000000000000377b1426e1e1857f300907c39678bab9d2", - "0x00000000000000000000000000000000001f460fe6b26626b496ca4a53dc2103", - "0x000000000000000000000000000000093cc8cd227239606f069fb8b0d89be197", - "0x00000000000000000000000000000000001d6ddaa3a6362872d4ad6f6ffdf26d", - "0x000000000000000000000000000000aaca84b607b945c22f9380968dca37b3dc", - "0x000000000000000000000000000000000006e37c218b5ddd9fe30f2d074af3ac", - "0x00000000000000000000000000000050ac5a5bfb200bb882053095cb7707c6c4", - "0x00000000000000000000000000000000002f598bce6b07a71ea18c892626f896", - "0x0000000000000000000000000000005981f7adfea2cb4c98608311c60dea02c0", - "0x0000000000000000000000000000000000289d38f2a30b52ebcfcda8ef0e441f", - "0x0000000000000000000000000000001b49052b5e34aed999b8b52e9496cbcc97", - "0x00000000000000000000000000000000000deaff0903f20c3a8781e8f36aeb29", - "0x00000000000000000000000000000013595eda489c2581add81a3054c537cde8", - "0x000000000000000000000000000000000016c291915bad74124a1089dd4e4b1e", - "0x0000000000000000000000000000009f60b0b20e50c2b872bbc2eba64d13d4dd", - "0x00000000000000000000000000000000002126fb29255849ef1cadd1b85f4ca6", - "0x00000000000000000000000000000018aa24e4df9dd2e6b857b79eb65063f442", - "0x00000000000000000000000000000000002bb078b426453481a11b32c23b5f17", - "0x000000000000000000000000000000471c619f4de581893a418a64ae1edbbf33", - "0x00000000000000000000000000000000000d33fe66c2a1ab73aa83ef5f9d6c1e", - "0x00000000000000000000000000000003cef58ea44be7d8c5d8d1639f1546b9d3", - "0x00000000000000000000000000000000001a5ca4c297a12ec7cbd3567570c84b", - "0x00000000000000000000000000000012c623f77652847ff7f2c87290036e946c", - "0x0000000000000000000000000000000000032e99aff3cb68a95f2493b6103618", - "0x0000000000000000000000000000003cabab340137b323e877e56cef1f8dbed8", - "0x00000000000000000000000000000000002986530e89170feacfa3abf1dc2bb2", - "0x000000000000000000000000000000b1af0f91346433e1a924e81e36062d5b12", - "0x00000000000000000000000000000000000fd850761ae3567a47c5015f5a49db", - "0x000000000000000000000000000000e96960409cc77dc83c19eb6c4a65a443bd", - "0x00000000000000000000000000000000002bc73c5cbad6a06c445f8c13667a0a", - "0x000000000000000000000000000000251d1a42e82570c38d16a0acb91075ff6f", - "0x0000000000000000000000000000000000252ab69e8a5eb85a7f07767a0b4cbd", - "0x000000000000000000000000000000775b0cbb24a05ae474393667bb23cbff4c", - "0x000000000000000000000000000000000020f65bb075b316367c63e1a78fa27f", - "0x00000000000000000000000000000045b7ffafdcdf6888cc39d9dca42576a396", - "0x000000000000000000000000000000000013c3af9f7d3e8d077e8765d6138d0d", - "0x00000000000000000000000000000061e4e7505a7274b9b128765e285681b6da", - "0x00000000000000000000000000000000000f860b75cc5deb976b9b05b8746e6b", - "0x0000000000000000000000000000003df46a7142e10868dc5980f6d2e13da00e", - "0x000000000000000000000000000000000022668e231bb6db8db665c18b46974f", - "0x000000000000000000000000000000dbf91bf91f60763e0c56fe43a8add14ab3", - "0x00000000000000000000000000000000002b6652da5918a262675f7b0ee80f9b", - "0x00000000000000000000000000000064092190c017f3620d4d39dad54d2f659d", - "0x00000000000000000000000000000000001be569b3318816be8bfafaeb38a0fe", - "0x000000000000000000000000000000e3d69f89db31d9400f666e59726928ef4c", - "0x00000000000000000000000000000000002757caef4b3a637a9aa7b191b32627", - "0x00000000000000000000000000000019852bf5ca19b13351bddedbf4335cb53f", - "0x00000000000000000000000000000000000b3498c424d7206a9dc3b30bcf4f7c", - "0x0000000000000000000000000000008fb1973e9d508a1b5258225627b8ecbfb4", - "0x000000000000000000000000000000000026f9f578430377663d282fe858e493", - "0x000000000000000000000000000000655c16efe629ce3bbb6555bc125d328ea9", - "0x00000000000000000000000000000000002c6140875c92938e10d156a43b9a9b" + "0x000000000000000000000000000000328fa44eadf895a91d60516902155f8f81", + "0x0000000000000000000000000000000000071b9cc79e0dca76ef8aa121fecb42", + "0x000000000000000000000000000000f643b83d95fb7587ac2fc95b9f12d855a2", + "0x00000000000000000000000000000000002b1fcc8551667432c54702bead052b" ] - hash = "0x04fbc459fb16d984f4019cc33c1eb7d791a57a8307d473858a0d5b44c202e230" + hash = "0x0fc08e493f377c56c666df99d9f3a5dbae52b12f02c75885ea759a74406efa80" [[inputs.previous_rollups]] proof = [ @@ -1436,8 +1438,10 @@ proof = [ ] [inputs.previous_rollups.public_inputs] + start_inbox_rolling_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" + end_inbox_rolling_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" checkpoint_header_hashes = [ - "0x004395c583aa5d8b61d95de30020015595c6ff15a98a908376053c285e760047", + "0x000cfde21e83a0343004234b288d8d226c9818897a0a8d0bc7454abcfe854cb1", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -1472,33 +1476,33 @@ proof = [ ] [inputs.previous_rollups.public_inputs.constants] - chain_id = "0x0000000000000000000000000000000000000000000000000000000000007a69" - version = "0x000000000000000000000000000000000000000000000000000000005fe47cc3" - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - protocol_contracts_hash = "0x080e3881bdd4a4e78d52691e5543b50cf820f51baf52af42d7b58c9e15f96ec7" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" + chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + version = "0x0000000000000000000000000000000000000000000000000000000000000000" + vk_tree_root = "0x21cd94941458effa5bf748eb3839418d3deb6bdcd2c04148ca733561265326a5" + protocol_contracts_hash = "0x0a1f22b72996215e178699fff463a6ca5e3c7d5ffe66e183490eb766ec1c83ae" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.previous_archive] - root = "0x1302274e4a6bea5811bcdf1a547430241566bcecab5eb026ced46711d8e78501" - next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000a" + root = "0x02b050244b9b298112dc7ce705838f55beca1ba7747d34532f285660519c21a6" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [inputs.previous_rollups.public_inputs.new_archive] - root = "0x119b91fb8888367eb1a374fd489be3f5b034be672409857b5921f06d85523269" - next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000b" + root = "0x2488836a12872bcea83608cfd8062c8548aaf16c1e55ff8b8af17debdb537d20" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000003" [inputs.previous_rollups.public_inputs.previous_out_hash] - root = "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093" + root = "0x0003e0e323f66d29e6a69f447a88e682190ce3e0a2546cb3e7f4a3ee4a31f1f8" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [inputs.previous_rollups.public_inputs.new_out_hash] - root = "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093" + root = "0x003b613be7a069f0b767725574398f44f0e974cf9710decbe80ad27194d6acaf" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [[inputs.previous_rollups.public_inputs.fees]] - value = "0x00000000000000000000000000000000000000000000000000030e6f24b2fa80" + value = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.fees.recipient] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [[inputs.previous_rollups.public_inputs.fees]] value = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -1687,15 +1691,15 @@ proof = [ inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.start_blob_accumulator] - blob_commitments_hash_acc = "0x00c7d69903605c24450d8cc4111d6b01e31f84cacd7a01402f0cef9f221f27f3" - z_acc = "0x1beeba27d94c66514c35883c6684bfdc767455041a16225205c326fd2e2cb7fc" - gamma_acc = "0x088bb68a165bc27058fd98272ebe5f98cb66378ebc3d5c2639d6f59a66e134ca" + blob_commitments_hash_acc = "0x00c52b72f554c05bf88d89c15b72dfe195c63faae292a2545603eaf2b7c4b179" + z_acc = "0x166af4d9536b4efc740544b393d04d0954d9c9f2e1a920e767d82c840a9ed746" + gamma_acc = "0x292bd05c3e9242b3c86b92c09c6ee6122bd52c3bf36f974011135ffdf833d2b2" [inputs.previous_rollups.public_inputs.start_blob_accumulator.y_acc] limbs = [ - "0x523fafae630b01cb88597856ec2ecc", - "0xf3db7c5d601e16ac93c5bbe54e70b7", - "0x31dc" + "0x2d0c8b1b37f5517da8437bbcbe12ca", + "0x47f9a79dce520c34f6ca66890c7b63", + "0x10e5" ] [inputs.previous_rollups.public_inputs.start_blob_accumulator.c_acc] @@ -1703,37 +1707,37 @@ proof = [ [inputs.previous_rollups.public_inputs.start_blob_accumulator.c_acc.x] limbs = [ - "0xdc0744575b26b4c4b7ee41dc7bee5a", - "0xab24ae0f1c266615b22dc3e9ffeecf", - "0xb738f18d636a06615561d266fd2d4d", - "0x19668e" + "0x9c080119e839655e99a11674011585", + "0x443513dc6fc3022a076e3e952493f9", + "0xa7c1b04b9b00d9dcb9541ef3a85eb1", + "0x16b0b9" ] [inputs.previous_rollups.public_inputs.start_blob_accumulator.c_acc.y] limbs = [ - "0x713d223616e8efe8cd4821efdde4f2", - "0x9a9a221be261841a9296b4d1eefd77", - "0xdb1af24cb0ccdcba1a7900c4fc1ad5", - "0x15b665" + "0xd77f761e6787b524a176983ef5b282", + "0xd76279f520567e299f71b8309d68a6", + "0x5eb62a7b495df2bb3ba3f3fcf8ad34", + "0x018120" ] [inputs.previous_rollups.public_inputs.start_blob_accumulator.gamma_pow_acc] limbs = [ - "0x3091f45075ebc6c0e8bd0d0b55148a", - "0xba36f4511ca8e170b8a14a64a7418f", - "0x070d" + "0xf940154dc87997c7e9369e713db21a", + "0xdb732975b8d0f86074d187d4b1d3ca", + "0x1364" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator] - blob_commitments_hash_acc = "0x00fbe8b1a1759d43e9105404b28cac4aecff4e95738d70e4cccaac168b420e22" - z_acc = "0x176add1054eec877e808c664abb8ebc1baff3b041ab083467209f38654f8753d" - gamma_acc = "0x0de90da6a38dfce59b8d0f833c1bfe3e16e0eb560794083f8b7cc496599b710f" + blob_commitments_hash_acc = "0x0057b5140aedfb5847896ce2058d1e5f9af947dcd4e4813cf6cf8e8fbce80c14" + z_acc = "0x2f3d7697b5c1b888aeb413d2f335e07ee5ea629f5fff25cdbc67aea92ac34043" + gamma_acc = "0x043fec643a7b59aed1b7ae290a3744c7f5eaed61559bec95611a2d882c2bb24f" [inputs.previous_rollups.public_inputs.end_blob_accumulator.y_acc] limbs = [ - "0xdf0081c38d524980410d61db922503", - "0x62517b1dfbda85451c0439cc0806e0", - "0x4d17" + "0x7a4c8327a30b495fcc8c9ae330cf75", + "0x52f62c30b8b51d586d567c3dd189cd", + "0x28b8" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc] @@ -1741,165 +1745,165 @@ proof = [ [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc.x] limbs = [ - "0x03625c74c2be70b1c311884cc7e585", - "0x6f620dfe7adc0c51d6ee59c585191e", - "0x0bed8a0ba276719689b549269aef57", - "0x18eb5e" + "0xe9d816658d35fb014a4c79defe5c25", + "0xde3342302108dd509e37efaee7c927", + "0x08f9f3c4a60a19f665329d17e29459", + "0x0fa5c4" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc.y] limbs = [ - "0x4683126714b4a2600b4aeb2ba09cb1", - "0x39d8a2712f7099eac558d4cb10484b", - "0xc15888f6212e3918f05f094bae5012", - "0x16bebd" + "0x76bd186cfb674b3cdd4f12c3c27146", + "0x21022064cac9c09dc68a83037f99ec", + "0x0bf5f89a9420a5c2fa604563056c8d", + "0x058ad0" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.gamma_pow_acc] limbs = [ - "0xeb2cbe158831bbbac06ed1f495640a", - "0x1557369df375c0edf8fdd550186e8e", - "0x5598" + "0xbae55d4d195ba7a29d630ca55a46cc", + "0x63ce01cf43aabc72aaa0c03ffb5482", + "0x58e1" ] [inputs.previous_rollups.public_inputs.final_blob_challenges] - z = "0x1fdc12adc29013642cd3e65ed4fe6257a51f0de3dbf9aab308d2eb764d2e2a6c" + z = "0x01d061ec599485ae8e2d63571790851cb49e4f2e838ca555550b4c3724750a50" [inputs.previous_rollups.public_inputs.final_blob_challenges.gamma] limbs = [ - "0x3091f45075ebc6c0e8bd0d0b55148a", - "0xba36f4511ca8e170b8a14a64a7418f", - "0x070d" + "0xf940154dc87997c7e9369e713db21a", + "0xdb732975b8d0f86074d187d4b1d3ca", + "0x1364" ] [inputs.previous_rollups.vk_data] leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000011" sibling_path = [ - "0x233055a6920a13764c09bad668c75e48f8165a1894c37152ede5c09640a63b15", - "0x2c74d12f23eca40b1748248d689d41cb7ac4771cecfe01c3ae67dab27f821949", - "0x035c573a1f2634405482213a2b805e186d6b81073e2b7a5bd3f64c2e4e8bc21e", - "0x033c4d295fe10d44c10ab7dd6b98731454b30ab8a3b175477338750c07bc4023", - "0x234c347546637311dad66534e5274a6a5db5da51b51baab040dac88807024ce5", - "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" + "0x0c10eb598741660f2160b4a6fe77191ad0c218b3a5f0ec4b8ebfecffaec4e4b9", + "0x121157fe0e38fc9db652bd52835686237090ef182f269df6fe777c5e5fd48aad", + "0x2e786d2377d9994a6dab998e113d87924b5b55a476ff385d0c66bcbb91158c60", + "0x20738d93e695096c6290e7c275252b87c3fc8a419bd4d9991368484bcbd446a7", + "0x2ea23c9cbeafe466f3725ea750741efad48745849cf61628cb3cd0e6156c6246", + "0x187a7b8872d1297bc15f7171f32c36e5e60b53c4145ef62b1899c04fd7220fdf", + "0x2ccaede67145021b6b586f45936dfbdacb151c3e362621c3598ffd60e95b02a0" ] [inputs.previous_rollups.vk_data.vk] key = [ "0x0000000000000000000000000000000000000000000000000000000000000017", - "0x00000000000000000000000000000000000000000000000000000000000000a3", + "0x00000000000000000000000000000000000000000000000000000000000000a5", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x000000000000000000000000000000744c51f21e3dd8540bccf510ecc1d766be", - "0x00000000000000000000000000000000001e95a14c474168aaa5c9372f7a0abf", - "0x000000000000000000000000000000879082cb89dbf870ad3aa0d5da2ee67125", - "0x0000000000000000000000000000000000192656445ad3e71909ee40b06deeaf", - "0x000000000000000000000000000000e1909fba28938423134c0d59b76683863d", - "0x0000000000000000000000000000000000003e26f42f57c6e694c1e7e40b17c6", - "0x0000000000000000000000000000002a188fa67065c4bcc359cb5fd771dabcb6", - "0x0000000000000000000000000000000000160ac0b054344bb77bac08ac568575", - "0x000000000000000000000000000000fc970af33d774376cf02d202aaef414ba5", - "0x000000000000000000000000000000000021c2bd629cd0a533238d0ab831f778", - "0x00000000000000000000000000000068db97499ceb5bc0ee7a25f7b9474f2b8d", - "0x0000000000000000000000000000000000177f1d3bcc53dc664aeffa8f221982", - "0x00000000000000000000000000000071bf5b67b8cc7197d679fb2c9b28eff994", - "0x000000000000000000000000000000000004d0af735c0dba71607923878247b9", - "0x000000000000000000000000000000f9dfca16db1889889cabadcb3c086a4f27", - "0x000000000000000000000000000000000000ab2307518eeb29981848b3d1ee07", - "0x000000000000000000000000000000d6bffac49573916cfa0c7fc812ecbba5b6", - "0x000000000000000000000000000000000009655ac19e9e344b05e4a2fdce84c7", - "0x000000000000000000000000000000f7755de133f87eac380cca4fb5d60afa6f", - "0x00000000000000000000000000000000001d7cff28580bdd7cfbc17f159c5620", - "0x0000000000000000000000000000007f26c16746a68d8270726a65373e58c426", - "0x00000000000000000000000000000000001bcc461c1faa451fd1a0ed4683c3c0", - "0x000000000000000000000000000000ae6f4726a6e0f83357befc61e67a9ca001", - "0x00000000000000000000000000000000001ef4f7456ae1908e7a90de3d05cff2", - "0x00000000000000000000000000000017d5cef864c8bae29b2bec7712603477e6", - "0x00000000000000000000000000000000000c2947db29055b93c4ab5b26120a74", - "0x0000000000000000000000000000003a28bc16570b9a581942c4f4a5978e6455", - "0x0000000000000000000000000000000000297af63688110e42582a51c7fce3a5", - "0x0000000000000000000000000000008de422f0c439a79c6fe60b90f08dfe1498", - "0x00000000000000000000000000000000001c56ba82c1f1910eb581559e94ae3c", - "0x0000000000000000000000000000006fa0127d67c2462bec9945343f82c18b62", - "0x00000000000000000000000000000000001ab9b001ba47aa775c9094ccff2543", + "0x0000000000000000000000000000003288730860744d90f8dcdc13940fc8d87e", + "0x00000000000000000000000000000000001a6480ae73e5d86fc292b430b8a751", + "0x0000000000000000000000000000006917a325f36c3d0079ea3a8a3f1163f738", + "0x0000000000000000000000000000000000040b3b47fc35b7e61722173a8585ca", + "0x000000000000000000000000000000bd731678729bd1076face8dda8d5fdd33e", + "0x000000000000000000000000000000000010d5115052c7b5d12f7f7fd39c73b1", + "0x000000000000000000000000000000143cbf9cb288d55c919de0d3c6b5f418d8", + "0x000000000000000000000000000000000017dbc3182e0956e2ed401eabcc8f94", + "0x00000000000000000000000000000079c549a08f8e493ac82a3298d5020166a1", + "0x00000000000000000000000000000000000f15af4534a6f141858cc1ea55d87c", + "0x0000000000000000000000000000000d5ecf557d36b122ff3d2384ed60de9d98", + "0x000000000000000000000000000000000008816a47846bc89240d2e13c362be1", + "0x000000000000000000000000000000e315f3df73d78bae1d02fa60b3a7a3ec68", + "0x0000000000000000000000000000000000093e3211a055f01f562492428baea9", + "0x00000000000000000000000000000027ebb9883a8e78bd492c14bd0cb85a6e19", + "0x00000000000000000000000000000000001b7795648f8c1f9c520a9f842dc5be", + "0x00000000000000000000000000000035a06493c8f34e1fae3efa0c4c3d529858", + "0x00000000000000000000000000000000002456fd877795105f730069fc1fb9ef", + "0x000000000000000000000000000000c30ebb23e62d30c6a395834e91224c7111", + "0x000000000000000000000000000000000028e695b7da8c77dc517e5e3cc3c28d", + "0x0000000000000000000000000000006720355f00860876fb20c803fcddcf9b4e", + "0x00000000000000000000000000000000000ab7e9481137a97e36d8ced967c1ed", + "0x000000000000000000000000000000fcc8b48bedce5374db954ff6d9d4e5d59a", + "0x00000000000000000000000000000000001134dbc1b6735b7ebc219367c7cbbc", + "0x000000000000000000000000000000dd98d271d4d16e66d61039d006fdb08dd2", + "0x00000000000000000000000000000000002646eb78d367e3ddae2ee29657e78f", + "0x0000000000000000000000000000006e859a711aa7352e651b1b48330125a03a", + "0x000000000000000000000000000000000021784c3d16da5e715233b84c49fe1b", + "0x000000000000000000000000000000d4eed6e91e831b6232254e64a82fa8d212", + "0x00000000000000000000000000000000000b106a845234acad6cfaffc55cf2ff", + "0x0000000000000000000000000000005194ac5554bc31446a2822c2a90ee5d536", + "0x00000000000000000000000000000000001a0209e186160b00c1d9f45845ad40", + "0x000000000000000000000000000000513eaa372ee3ab77c56296538ca4437f01", + "0x000000000000000000000000000000000017aa55310d97d1bef2ce1f2a2e58f5", + "0x000000000000000000000000000000547582ffb04f9f2dc83dc8dd4ac9353afa", + "0x000000000000000000000000000000000009f0c660d3c44b7d47f82eae5c6e37", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000006691d9edd4281b4d8c7bfe7cf2114dbed0", + "0x00000000000000000000000000000000002f785826e92b236b3f40d64938a8af", + "0x0000000000000000000000000000001f2e233e205ebb1de17e51bd42bd2a6709", + "0x0000000000000000000000000000000000244972df89429a8780722959797160", + "0x000000000000000000000000000000a08687feb5bb3bbe8fa68abee82250cf45", + "0x00000000000000000000000000000000002b5b8e1d2121016a592d83cddf49fa", + "0x000000000000000000000000000000bc66f21b8eed9da44989f70a272822b6f7", + "0x000000000000000000000000000000000023bccb8cecf793ebbb1bda19fd1490", + "0x00000000000000000000000000000062017a22ba729a464723c1312a7b69c9bc", + "0x00000000000000000000000000000000001dac218f0b46fda3d521146527e842", + "0x000000000000000000000000000000ca406376e1831ce97513fe24aeed962561", + "0x0000000000000000000000000000000000294fc4df9082aa7fd5b670738928ec", + "0x0000000000000000000000000000008b9b647e54171de19e0b6f93ef5e48ac1b", + "0x00000000000000000000000000000000000f9038e596e4bc37a8636a2d461327", + "0x0000000000000000000000000000009f1ce1c28c8577cfc8339465e9d8f5b742", + "0x00000000000000000000000000000000001309f9dda0064b07081016e15d07ad", + "0x00000000000000000000000000000024222df0aa0ffa760557d17021c98eece7", + "0x00000000000000000000000000000000001d15b2767580e54d9ea596a65c9523", + "0x000000000000000000000000000000df15a11026f7fac6f9d648764a34019e0f", + "0x00000000000000000000000000000000002ce785169d9a643bb94c4af25cd196", + "0x000000000000000000000000000000308adcca358d6672a7b1866c24db257984", + "0x0000000000000000000000000000000000125b3d6f343c08e90f7a5c5e9d1711", + "0x000000000000000000000000000000e5dfaa669b75a8b832f3ae92f41a676f75", + "0x0000000000000000000000000000000000130e53472be61d363fe04154c25ad8", + "0x000000000000000000000000000000b77240211fc58c69db333948fec925ae5b", + "0x00000000000000000000000000000000000885c9c1fa31d3e07be8a05b37c862", + "0x0000000000000000000000000000003e1988529ef3e8c0f71d3bb9c5eabb0c93", + "0x00000000000000000000000000000000002f259eb9cf86aa730d5fd3307582c7", + "0x000000000000000000000000000000ff9c398f86a183fcbc41c36d7ea5486f44", + "0x00000000000000000000000000000000001d741554ae0921d8439277b831b59f", + "0x00000000000000000000000000000072f4ba06e6c859cafd74b8be78f4e6c290", + "0x000000000000000000000000000000000013c4ca91ce5c6256578e79b70a67f0", + "0x0000000000000000000000000000000dd655425a18bf1b28d418c22e417aed28", + "0x0000000000000000000000000000000000020fc7fbb26d277c22bd7780447291", + "0x000000000000000000000000000000ffb9ad1af1a082c77b4e0810594467c569", + "0x000000000000000000000000000000000020aa42c226d5a0970630ddbb783f38", + "0x000000000000000000000000000000bf3e76d8f3f21653422411fcd9a2bd5ae0", + "0x0000000000000000000000000000000000187d106d31fd0f38d51f99eab75ce7", + "0x000000000000000000000000000000cbf23559d5b4a16dc60742408bc4d980c8", + "0x00000000000000000000000000000000001fd1cc7837e440e779a50f76b58a2e", + "0x000000000000000000000000000000eb62206940246d32198b3141bc6a50abac", + "0x0000000000000000000000000000000000037f231e8cd28f0f8ad3cb5f466032", + "0x000000000000000000000000000000efc0ca88f857d42b88ac1ac92d9374b62d", + "0x00000000000000000000000000000000001fd02630798bd4633975daf091b593", + "0x000000000000000000000000000000da2f92a05047e7e8b1a822549759808b83", + "0x000000000000000000000000000000000001084dd81798c00eeb2887f2df9620", + "0x00000000000000000000000000000011fc26a27e002528f461224894ccd240ee", + "0x00000000000000000000000000000000001534fa0d9bbd25eba2f122eaad06bc", + "0x0000000000000000000000000000009f3672e356e98b3a7a3deae61a9b87dd29", + "0x0000000000000000000000000000000000301cc7d23879687ec5cbdc195436f9", + "0x00000000000000000000000000000023885c7bce9e0d10196c6f831bf4b229de", + "0x00000000000000000000000000000000001602ff1fe4f4cb70c26ad5bc16858a", + "0x000000000000000000000000000000fcf2a0c1eceb385200a0ee09c40c758fbf", + "0x0000000000000000000000000000000000253b9dd23a0982e9db87324acd9aba", + "0x00000000000000000000000000000097a1599a0f5c04ef46d89bc4be8629ed3f", + "0x00000000000000000000000000000000002ef5dbc090a304ab4d948f1e08a8de", + "0x000000000000000000000000000000691acea534b501c5d7a5984cbb56e2f677", + "0x0000000000000000000000000000000000256377fe9f1696e2316a0ede70e194", + "0x000000000000000000000000000000b1d93380e5a238c52f4d9327b8ff615f45", + "0x0000000000000000000000000000000000029f05bf11aee014fc3ca870e42dc7", + "0x00000000000000000000000000000083f400e03505d6e2e6a8d315ec5b24f54c", + "0x00000000000000000000000000000000000c031249619645a60ab26bf3069331", + "0x0000000000000000000000000000006e7016f5ace833e2821d171ef0fe2b9f8d", + "0x00000000000000000000000000000000000f8b062a1227fc7a323aed56615912", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x0000000000000000000000000000001aafcb2e2c5b4ee357c3cf460fa8614ed8", - "0x00000000000000000000000000000000000d7a76e33e068c44cecba8c22ae8d7", - "0x000000000000000000000000000000492fb683c7e0e137bc4e2ea86c37740b5c", - "0x0000000000000000000000000000000000206f337fb8b6d365b941ba4a8d8a9c", - "0x000000000000000000000000000000577c33d5c10b485d8c213d16ac4664dd62", - "0x00000000000000000000000000000000001dbb32af825db919015b2f62ac527a", - "0x0000000000000000000000000000004089798ec9503f6d851e3f36c8134fffca", - "0x0000000000000000000000000000000000258c2a8625473699411a82c908b205", - "0x00000000000000000000000000000039e66e47fbf20c042e57bc7b20b446fef5", - "0x00000000000000000000000000000000001a7afcba66a6d1561b93bbc1af74f6", - "0x0000000000000000000000000000002455981c887b06eaa76d3e33d58c191122", - "0x00000000000000000000000000000000001de23e2477dda30d3d197f197ac419", - "0x000000000000000000000000000000b116578da6236d15e82788782d873df37f", - "0x0000000000000000000000000000000000269873dc9e65f74c789d8a58db0077", - "0x000000000000000000000000000000ee7cf9691c5ad6f6e90099bc5d04408a73", - "0x0000000000000000000000000000000000284704a1b995c3a251204d4c6c01a2", - "0x0000000000000000000000000000004d63dd4c7af54fcf2e481be7293211350b", - "0x000000000000000000000000000000000003805c1292ab954706ed7e0cca9281", - "0x0000000000000000000000000000006572fd92d3bf1845cceeef0a7f0d044f8b", - "0x00000000000000000000000000000000000641fb756d60be4b60f5c0a76f6930", - "0x0000000000000000000000000000003c9242ea4df53612f2943b641741fb9359", - "0x00000000000000000000000000000000002ebb3334e2b6b702d04d94e2c6a5c4", - "0x0000000000000000000000000000004be64b431a5a816b719da16e8e02535892", - "0x000000000000000000000000000000000001339afc1567176d3527faaf56c0a0", - "0x000000000000000000000000000000377b1426e1e1857f300907c39678bab9d2", - "0x00000000000000000000000000000000001f460fe6b26626b496ca4a53dc2103", - "0x000000000000000000000000000000093cc8cd227239606f069fb8b0d89be197", - "0x00000000000000000000000000000000001d6ddaa3a6362872d4ad6f6ffdf26d", - "0x000000000000000000000000000000aaca84b607b945c22f9380968dca37b3dc", - "0x000000000000000000000000000000000006e37c218b5ddd9fe30f2d074af3ac", - "0x00000000000000000000000000000050ac5a5bfb200bb882053095cb7707c6c4", - "0x00000000000000000000000000000000002f598bce6b07a71ea18c892626f896", - "0x0000000000000000000000000000005981f7adfea2cb4c98608311c60dea02c0", - "0x0000000000000000000000000000000000289d38f2a30b52ebcfcda8ef0e441f", - "0x0000000000000000000000000000001b49052b5e34aed999b8b52e9496cbcc97", - "0x00000000000000000000000000000000000deaff0903f20c3a8781e8f36aeb29", - "0x00000000000000000000000000000013595eda489c2581add81a3054c537cde8", - "0x000000000000000000000000000000000016c291915bad74124a1089dd4e4b1e", - "0x0000000000000000000000000000009f60b0b20e50c2b872bbc2eba64d13d4dd", - "0x00000000000000000000000000000000002126fb29255849ef1cadd1b85f4ca6", - "0x00000000000000000000000000000018aa24e4df9dd2e6b857b79eb65063f442", - "0x00000000000000000000000000000000002bb078b426453481a11b32c23b5f17", - "0x000000000000000000000000000000471c619f4de581893a418a64ae1edbbf33", - "0x00000000000000000000000000000000000d33fe66c2a1ab73aa83ef5f9d6c1e", - "0x00000000000000000000000000000003cef58ea44be7d8c5d8d1639f1546b9d3", - "0x00000000000000000000000000000000001a5ca4c297a12ec7cbd3567570c84b", - "0x00000000000000000000000000000012c623f77652847ff7f2c87290036e946c", - "0x0000000000000000000000000000000000032e99aff3cb68a95f2493b6103618", - "0x0000000000000000000000000000003cabab340137b323e877e56cef1f8dbed8", - "0x00000000000000000000000000000000002986530e89170feacfa3abf1dc2bb2", - "0x000000000000000000000000000000b1af0f91346433e1a924e81e36062d5b12", - "0x00000000000000000000000000000000000fd850761ae3567a47c5015f5a49db", - "0x000000000000000000000000000000e96960409cc77dc83c19eb6c4a65a443bd", - "0x00000000000000000000000000000000002bc73c5cbad6a06c445f8c13667a0a", - "0x000000000000000000000000000000251d1a42e82570c38d16a0acb91075ff6f", - "0x0000000000000000000000000000000000252ab69e8a5eb85a7f07767a0b4cbd", - "0x000000000000000000000000000000775b0cbb24a05ae474393667bb23cbff4c", - "0x000000000000000000000000000000000020f65bb075b316367c63e1a78fa27f", - "0x00000000000000000000000000000045b7ffafdcdf6888cc39d9dca42576a396", - "0x000000000000000000000000000000000013c3af9f7d3e8d077e8765d6138d0d", - "0x00000000000000000000000000000061e4e7505a7274b9b128765e285681b6da", - "0x00000000000000000000000000000000000f860b75cc5deb976b9b05b8746e6b", - "0x0000000000000000000000000000003df46a7142e10868dc5980f6d2e13da00e", - "0x000000000000000000000000000000000022668e231bb6db8db665c18b46974f", - "0x000000000000000000000000000000dbf91bf91f60763e0c56fe43a8add14ab3", - "0x00000000000000000000000000000000002b6652da5918a262675f7b0ee80f9b", - "0x00000000000000000000000000000064092190c017f3620d4d39dad54d2f659d", - "0x00000000000000000000000000000000001be569b3318816be8bfafaeb38a0fe", - "0x000000000000000000000000000000e3d69f89db31d9400f666e59726928ef4c", - "0x00000000000000000000000000000000002757caef4b3a637a9aa7b191b32627", - "0x00000000000000000000000000000019852bf5ca19b13351bddedbf4335cb53f", - "0x00000000000000000000000000000000000b3498c424d7206a9dc3b30bcf4f7c", - "0x0000000000000000000000000000008fb1973e9d508a1b5258225627b8ecbfb4", - "0x000000000000000000000000000000000026f9f578430377663d282fe858e493", - "0x000000000000000000000000000000655c16efe629ce3bbb6555bc125d328ea9", - "0x00000000000000000000000000000000002c6140875c92938e10d156a43b9a9b" + "0x000000000000000000000000000000328fa44eadf895a91d60516902155f8f81", + "0x0000000000000000000000000000000000071b9cc79e0dca76ef8aa121fecb42", + "0x000000000000000000000000000000f643b83d95fb7587ac2fc95b9f12d855a2", + "0x00000000000000000000000000000000002b1fcc8551667432c54702bead052b" ] - hash = "0x04fbc459fb16d984f4019cc33c1eb7d791a57a8307d473858a0d5b44c202e230" + hash = "0x0fc08e493f377c56c666df99d9f3a5dbae52b12f02c75885ea759a74406efa80" diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-root-single-block/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-root-single-block/Prover.toml index 72539e72bd18..5db72505752d 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-root-single-block/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-root-single-block/Prover.toml @@ -483,70 +483,70 @@ proof = [ ] [inputs.previous_rollup.public_inputs] - timestamp = "0x000000000000000000000000000000000000000000000000000000006a4d22fd" - block_headers_hash = "0x2efa5fe41af017572583e705fc35f6b2eede2df0257526bbee6536817b583a11" - in_hash = "0x00de7b349d2306334734e4f58b1302a6ed5a6c796a706f6597a5641b6d468223" - out_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" - accumulated_fees = "0x00000000000000000000000000000000000000000000000000198e45581dc500" - accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000008992c" + timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186" + block_headers_hash = "0x208a3cb0fe159e10bedc972a94e90162968d3f9a85ebdb04152766132c98f584" + is_first_block = true + out_hash = "0x00746f2611b7b24448263e846ba73bf1861fc6e68dbc605414405a520957a902" + accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" + accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0" [inputs.previous_rollup.public_inputs.constants] - chain_id = "0x0000000000000000000000000000000000000000000000000000000000007a69" - version = "0x000000000000000000000000000000000000000000000000000000005fe47cc3" - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - protocol_contracts_hash = "0x080e3881bdd4a4e78d52691e5543b50cf820f51baf52af42d7b58c9e15f96ec7" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" - slot_number = "0x0000000000000000000000000000000000000000000000000000000000000044" + chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + version = "0x0000000000000000000000000000000000000000000000000000000000000000" + vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f" [inputs.previous_rollup.public_inputs.constants.coinbase] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.constants.fee_recipient] inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.constants.gas_fees] fee_per_da_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" - fee_per_l2_gas = "0x00000000000000000000000000000000000000000000000000000002f8e08bc0" + fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.previous_archive] - root = "0x1842a814b068f699565f4df77ab9139f1cfab687ef959bf92ba0bb3adf93d8dd" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000009" + root = "0x0fb2945d3438d906d88a216364dbfe9760e96001343468610e01d18182d493d0" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [inputs.previous_rollup.public_inputs.new_archive] - root = "0x1302274e4a6bea5811bcdf1a547430241566bcecab5eb026ced46711d8e78501" - next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000a" + root = "0x2add6cae011a2faa69aa2bc34c04687c5fbeaae52aea0f903adb94762d03971f" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [inputs.previous_rollup.public_inputs.start_state.l1_to_l2_message_tree] root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000001800" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.start_state.partial.note_hash_tree] -root = "0x034b30004686b0cbe57927eaa548af4a428eabee71f4e3e8a581a43084facde5" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000140" +root = "0x2590f2aab19dd791700b4a43d3f52bb88ef2409a3731da8e848663559202e4c6" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollup.public_inputs.start_state.partial.nullifier_tree] -root = "0x1c13b69ab508e560dc7c25e4f77aed48439749310a58609f31475734efe7287b" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000001c0" +root = "0x18935581a8ed73d08ffd00386fba55ba6c89f3ab848a76b8fedfa9034cee0454" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollup.public_inputs.start_state.partial.public_data_tree] -root = "0x073b8408b98dbac4d5f0c84d47161ee954b8d8e7920e620bf14bc44cb50d07d5" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000008b" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollup.public_inputs.end_state.l1_to_l2_message_tree] -root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000001c00" +root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollup.public_inputs.end_state.partial.note_hash_tree] -root = "0x034b30004686b0cbe57927eaa548af4a428eabee71f4e3e8a581a43084facde5" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000180" +root = "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollup.public_inputs.end_state.partial.nullifier_tree] -root = "0x00260be7577812f167b02eb1c2fa10efc5f169fe19845ada374d4c1518af35f4" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000200" +root = "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" [inputs.previous_rollup.public_inputs.end_state.partial.public_data_tree] -root = "0x2536a3212b711359308d274b8a92fa44465b6ce091dd9369c1331f1ffdeaa8ca" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000008b" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollup.public_inputs.start_sponge_blob] num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -567,2788 +567,3414 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 squeeze_mode = false [inputs.previous_rollup.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000087" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a1f" [inputs.previous_rollup.public_inputs.end_sponge_blob.sponge] cache = [ - "0x00260be7577812f167b02eb1c2fa10efc5f169fe19845ada374d4c1518af35f4", - "0x2536a3212b711359308d274b8a92fa44465b6ce091dd9369c1331f1ffdeaa8ca", - "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a" + "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759", + "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b", + "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00" +] + state = [ + "0x06084df33e0811da8ace72d79c2824a36d6bec3651ccb23d13f6ae9962295300", + "0x214def13bbb6728a31cbd5abedd397e1a966d1e61b08dd2c4543e25b6c01fa23", + "0x174a927fc7f8d5a40b9d9b76056de635aa0b3e63c245508278b2acf001b4043b", + "0x11f525d74163bc4b0a390db4e5066a1d641776946a8c3642c9c3467ed5d26656" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" + squeeze_mode = false + + [inputs.previous_rollup.public_inputs.start_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.previous_rollup.public_inputs.start_msg_sponge.sponge] + cache = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + state = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000000" + squeeze_mode = false + + [inputs.previous_rollup.public_inputs.end_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.previous_rollup.public_inputs.end_msg_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" ] state = [ - "0x09c5a5ce332193157aff3f33e91b102d9e4d89d1bc75f3b3f35c15671c59c0ed", - "0x12dec657347c4b34a75cd95ad1e3bc343bb7800797a8c0a4036f88793cf0e32f", - "0x187c15e04638cd020e01c721b80acbe5905daf8670de1219385cc7e6838b25b5", - "0x22b3946d4e314d5204db5a09eccd5fddfec86678582867a5bbda12432a2dd64f" + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" ] - cache_size = "0x0000000000000000000000000000000000000000000000000000000000000003" + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" squeeze_mode = false [inputs.previous_rollup.vk_data] - leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000b" + leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000a" sibling_path = [ - "0x02904385b9df599026d8b15d1015623ccc1b22881f9cdae1f57b519af5580631", - "0x0f63dbbd49436fb3261c320d539cfbec7d375147081e6787c7ae161d25a9581d", - "0x0a2818ba5dd5624d91f012822293d4135b8958ec1d8ab6cf952ee3de138bb8c4", + "0x21b05869a0933a9cc299b7ef0465dff532b164271541fe768f96c81a9a0ef271", + "0x27bb42fdafee24ce9055d6a52cd49d943c577b8f98284557d76900b540761ce3", + "0x196cbe2980734bc5d21b53464a1d00c06dad0febdec75822d79d6933dff40579", "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd", - "0x2a17b9f268be22deec2941ce8de06f485f2d164710a5177d262a4ae86b7c351f", + "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d", "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" + "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd" ] [inputs.previous_rollup.vk_data.vk] key = [ "0x0000000000000000000000000000000000000000000000000000000000000015", - "0x0000000000000000000000000000000000000000000000000000000000000046", + "0x000000000000000000000000000000000000000000000000000000000000005a", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x00000000000000000000000000000024bc9db45b73e7fb4b2487a72e7a279fba", - "0x00000000000000000000000000000000002769a1528c44352e10b39f5bfea4a1", - "0x000000000000000000000000000000739f1925ed35ea2e2ca65ccb78e791f9ad", - "0x000000000000000000000000000000000018e6f35c3cb0460b3905f75ae7f4ae", - "0x00000000000000000000000000000060ddc6dad1ed0a6c59f22ebe8b844f6189", - "0x00000000000000000000000000000000001cd99394c4e85c1c915aa5beb9ce81", - "0x0000000000000000000000000000006dd43fb76256eb6d974b8f1ba8a8fa2f09", - "0x000000000000000000000000000000000016c881187c584a799be44d946986f9", - "0x0000000000000000000000000000008b0c7ba6da9f1d46c37b98cb132ddf095e", - "0x00000000000000000000000000000000002e5f96015a2d5b5e730b5a06838057", - "0x000000000000000000000000000000d3d571ca1486c4f824709e534f6391edf6", - "0x00000000000000000000000000000000000f3516049f253ca5bc12060df0f136", - "0x000000000000000000000000000000519d47be7b86bc7a814add890c8885f2ae", - "0x0000000000000000000000000000000000236167a2385bdd1c41518b152fa7ab", - "0x000000000000000000000000000000bfaf64390d931434b94523a713dcdcfd9b", - "0x00000000000000000000000000000000002ed601cb78e61cc724cf9de221fa9e", - "0x000000000000000000000000000000048d30fb3c70be3e6941f157cdd951b40c", - "0x0000000000000000000000000000000000134f003d3de1142df0709afe3a7e4c", - "0x0000000000000000000000000000001142be6efed3ac936ed3f1c413f464fc83", - "0x0000000000000000000000000000000000170c59933623a935ba06ef80525392", - "0x0000000000000000000000000000005286e1d6fe903602a25c2cb759ebe8c1d6", - "0x00000000000000000000000000000000001025946b613678c4c528cabfb3f67d", - "0x0000000000000000000000000000003d54230920d0431a760ef6d2d9decedf77", - "0x00000000000000000000000000000000000fe45d06cdb9e695183f54891c0818", - "0x000000000000000000000000000000c5f1918b891092e77d3f3e2e67ecebf5e8", - "0x000000000000000000000000000000000026d3f4339318924af66ebfdd5e577a", - "0x0000000000000000000000000000005cb2f39fb3bdaaeb130f34e1870346aacf", - "0x000000000000000000000000000000000013160f5368de16f01b817104643457", - "0x000000000000000000000000000000e8f2964ecb996ae83ee78e3d489a3f0ec2", - "0x00000000000000000000000000000000000de27bd975f399f37468aa9bdd3984", - "0x000000000000000000000000000000916a8213edb121f5c66404923cc32d26f4", - "0x00000000000000000000000000000000002adc79542e8feadf9aa61ba1bcf584", + "0x000000000000000000000000000000cf2a702e96bbbe5ac008f4f277c0d250eb", + "0x0000000000000000000000000000000000087ce4ee48dbfc015f06c1763c5239", + "0x0000000000000000000000000000008d42b724c37a913d7a5b994f4572740667", + "0x000000000000000000000000000000000023692a05ae3b76053633b3abf15253", + "0x000000000000000000000000000000255a61af1e11c2c00b732ecaa94329afdc", + "0x0000000000000000000000000000000000149df684fde38bdbfd676709893e92", + "0x000000000000000000000000000000d16e3f9132ca3344573770664919ca4068", + "0x00000000000000000000000000000000000ea348d7e01672556a386a149b8af8", + "0x00000000000000000000000000000080932903a97d817d697469cc4510c0b08c", + "0x00000000000000000000000000000000002d13575951a6dcce130eb32afc2e5c", + "0x000000000000000000000000000000d0111922d2459ad2180439139df2808f38", + "0x00000000000000000000000000000000000562a09897d6293cf85c879c37be00", + "0x000000000000000000000000000000412fc6f0e8f7adc114758e1785c709a67d", + "0x00000000000000000000000000000000000830b377f541c4310cde030b08cb91", + "0x000000000000000000000000000000fad5ecf349c6da3768be1b4282e3175d71", + "0x00000000000000000000000000000000001a0f8ca1f4ee77941f2e565da1a842", + "0x000000000000000000000000000000c4add37f10869cc94bb788aba7e40fa21a", + "0x00000000000000000000000000000000002c356385e26d3bced3606c9d634582", + "0x000000000000000000000000000000545a771e3a661ad0fe7516f8e3854b8b39", + "0x00000000000000000000000000000000002f607cf7edda4d345540d886b7b66d", + "0x0000000000000000000000000000009f98165c9f39940ee67940b105d09744e7", + "0x00000000000000000000000000000000002c73b9681021ee2103c7df20a985bd", + "0x000000000000000000000000000000dbfb3dbcfde7ac15bd841b876b31c00890", + "0x0000000000000000000000000000000000039f091ed585acfc694f23411ba5f4", + "0x00000000000000000000000000000048fe71f72808e64e21b630d5be985cb3c0", + "0x000000000000000000000000000000000014ccc7c54c5859ce789122703c09b7", + "0x00000000000000000000000000000093090e40108dad3330fb1163bdf2f9df36", + "0x00000000000000000000000000000000001b44a0bd7343f7e3c029e145a7a0f0", + "0x00000000000000000000000000000019064d6e42cbc110b2aff67863843f99a1", + "0x00000000000000000000000000000000001b47532036f3cc7da9869c441839be", + "0x00000000000000000000000000000057593add48ed37f0ae51949f9cefbf5ef6", + "0x00000000000000000000000000000000001ac725f39f2914f584e0ed3d0838a1", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x000000000000000000000000000000e6c6276dfc9b16e2931ef96898d84a82dd", - "0x00000000000000000000000000000000002e66f12a8a85fd18c91ca86c28060d", - "0x00000000000000000000000000000082a662ace0ebb2a55d6aa40a17c6b81e82", - "0x000000000000000000000000000000000003c7a450b7335348b6ce339f0b0cc6", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x000000000000000000000000000000b1adf6ee18274cb79bbaa249551703c604", - "0x00000000000000000000000000000000003018cc9a7ca8f8ef4023c27afbb616", - "0x00000000000000000000000000000006d726e31e712b8c8eb97fe520bb343a59", - "0x0000000000000000000000000000000000105db0db8ce9fbb93b3ee5cb90ad31", - "0x0000000000000000000000000000003a2e45fc6e2aa706adb32a0a64098e4e47", - "0x00000000000000000000000000000000002bc247d2a4cfdc6e7fea304220104e", - "0x000000000000000000000000000000093b7a0052b8f9d68df7e3dc5a4fb741fe", - "0x00000000000000000000000000000000002a7cee714ffd8e1ddf9ecddc5cf5e4", - "0x000000000000000000000000000000974c9ee433a23c20e6be26c38fe6a50f38", - "0x000000000000000000000000000000000000f384f19fec9dd45adf40cff33ea3", - "0x00000000000000000000000000000053b77cd88598168f8cbe8c18ee3662049b", - "0x00000000000000000000000000000000000177847cd2cc4ed48594f74560c178", - "0x0000000000000000000000000000001dcd9fc2d402b5463e3031c831b2b02bcd", - "0x000000000000000000000000000000000006d3280a20894689a5963e7efd000c", - "0x000000000000000000000000000000ef357aec8006ddb8396a3060f2af6f5757", - "0x00000000000000000000000000000000002203fe128291e0a96d5668c174f510", - "0x0000000000000000000000000000001d9eb9e9ca5c4749bedd1dc0db26e0b3e9", - "0x0000000000000000000000000000000000156f732f26d187f0af354881b02ff8", - "0x000000000000000000000000000000e0e35d86a2d0f68808a1f18320246dc3ca", - "0x00000000000000000000000000000000001b56dd24e59f145cfe958f31ee11ba", - "0x000000000000000000000000000000f6c162cdbd5e0907845b07814a38a5b70d", - "0x000000000000000000000000000000000006a9cc39e3832513e3db5ef5fe1356", - "0x000000000000000000000000000000449ce17638109f970b0f8b81d15ebb189f", - "0x000000000000000000000000000000000017eb50498175605c0fe7b80e445a04", - "0x00000000000000000000000000000002692c690e0806130ed7743f59ba8d5b57", - "0x000000000000000000000000000000000024885f0dad88c4e8ae637f7fa6e975", - "0x000000000000000000000000000000b79190581f9e7e22443deba5384fc79d42", - "0x00000000000000000000000000000000001c75f312d63b47dd4dded27cb0b01a", - "0x000000000000000000000000000000c73b713c18ab6d4a1427ccc6e416d6905f", - "0x000000000000000000000000000000000022b02f015c9b720cc74b56b0c0ad55", - "0x000000000000000000000000000000419241ffffa1f54d8f6399b195afc611a6", - "0x00000000000000000000000000000000001e96a8328d780d5b30c34f5778a16d", - "0x000000000000000000000000000000d256cc1d92056e3bf5e975cfe6449dbbe9", - "0x000000000000000000000000000000000006c6686cc48ddabf62c3bc1b0ffd22", - "0x000000000000000000000000000000e40d6630a0ae06492ec94b92103ad28108", - "0x000000000000000000000000000000000021d4f96cf23fe7998f35eacbf6bc76", - "0x00000000000000000000000000000055b3fb429246925b30fcee9ba51ff0d015", - "0x00000000000000000000000000000000000abbdd6aaead814196aa41542d15eb", - "0x00000000000000000000000000000069bac93130a7153ffd637bbc1696cb6cfe", - "0x000000000000000000000000000000000023a6843b4984921d6449c8c0861d99", - "0x000000000000000000000000000000255db62b6d7cdc3c9312a447d5bf2d49cb", - "0x00000000000000000000000000000000001a6be8b693df2c6ca087c4dc8286c7", - "0x00000000000000000000000000000000e11dc62dddeb3931735dc70559fa9938", - "0x00000000000000000000000000000000000fd5e82445a60979c1838f9d475ba9", - "0x00000000000000000000000000000086b491848efcba147344cf4623c5011e84", - "0x000000000000000000000000000000000024e299ae28d4f8e761778550a163ab", - "0x000000000000000000000000000000cdaf442fb6221a53909c441f5ae9a4e68c", - "0x00000000000000000000000000000000001bd8ab0913cac43548f2a8206f8d39", - "0x0000000000000000000000000000007af5cd832d815f050ff25d77bc7974ba7c", - "0x0000000000000000000000000000000000032946a4fc0df5dffe84eec2d5812c", - "0x000000000000000000000000000000d486e2809977417d0e65a6eab3df781940", - "0x0000000000000000000000000000000000286fa51b17dc4d47818fc47cc7790c" + "0x000000000000000000000000000000c24be3d5a24525e2b89ba9b0babaffc702", + "0x00000000000000000000000000000000002d75bac4aa7c28af5bf7e0a12a0f16", + "0x000000000000000000000000000000dd0483861422f1312c0850e56d5b93154a", + "0x000000000000000000000000000000000010558511f18b937ff5b2c2acd7ccf6", + "0x00000000000000000000000000000013e4441cf7e4a6a389a39dc21c24275be2", + "0x0000000000000000000000000000000000017aab51c397a2d57778ebe5022782", + "0x00000000000000000000000000000009adaeede4203a41f991031ec50f09bb98", + "0x00000000000000000000000000000000002c9fa3c370cbb1f1bc9128d27307d8", + "0x00000000000000000000000000000086f83dd5fa9178c3c683137ef6a3018c50", + "0x00000000000000000000000000000000000af8d38dc8b77bda3980c013658848", + "0x0000000000000000000000000000007307ee1df3133617f2e5a4d2bbb01f449f", + "0x00000000000000000000000000000000002e27ed3b0658fb9d44ebdb9e459679", + "0x00000000000000000000000000000037ec6f22980fbc5a795d816788a7c7fd87", + "0x000000000000000000000000000000000022973f4a5a82fd556aad37856af147", + "0x000000000000000000000000000000f6f48a91dac1f229b2b35e0fe3ef98abfb", + "0x000000000000000000000000000000000011b923ec095c6746d167d68a4b20e8", + "0x0000000000000000000000000000002d4825c2a902a49bad97fcf3510dea717e", + "0x00000000000000000000000000000000000a00b7e38d47dba44d1fa8d9e462d8", + "0x000000000000000000000000000000f14f2adda7c6729037603c11f6df57543b", + "0x00000000000000000000000000000000000bd236e34f1859cda4709a1895cdab", + "0x000000000000000000000000000000d3678bafd3a8f024c9373604ff3b9445e5", + "0x00000000000000000000000000000000002e41d5db4cb0fc20648504962c7e38", + "0x0000000000000000000000000000004ea6f803bdb1c654c7a3e38c2fc5747710", + "0x000000000000000000000000000000000012b2e307e4788fa75f5058585d1ba3", + "0x0000000000000000000000000000000aa62cd5ebf2ffdc52b78a3af8c439f083", + "0x000000000000000000000000000000000022e7f907354ae7ba479b2e162c2f69", + "0x0000000000000000000000000000002256de9ae3b3221dbadac5f8d7631bcb68", + "0x0000000000000000000000000000000000273453a329260d2302e4baea571bb0", + "0x0000000000000000000000000000001072d6d97a037355322cbcabe2fc386b6b", + "0x000000000000000000000000000000000024ad92d8eda5a97f51b847d96673de", + "0x000000000000000000000000000000d705cada5f49e0755ab5b25ae8b501ff1f", + "0x0000000000000000000000000000000000270554cc3a8a0a56751faa58835d58", + "0x00000000000000000000000000000009d082bb9fafab35b8e098aa12fbf59093", + "0x00000000000000000000000000000000000bcb7d6ca8b742b94b04f746c70db6", + "0x000000000000000000000000000000c77841ac534683173fc6b72068c8708c88", + "0x000000000000000000000000000000000027d93e6ccd49d0ad6fa7ce35a03831", + "0x0000000000000000000000000000007b8e5c440597cbb56a42b07032440282a3", + "0x0000000000000000000000000000000000263647505c66c8cd3939647d017fe2", + "0x00000000000000000000000000000007c0a9c4740001c2ab9708028921855ef3", + "0x00000000000000000000000000000000000cc3457d166e82882d5dfcd0851142", + "0x00000000000000000000000000000087f58fb22b0bf7c42ff4f6dbfe162b013b", + "0x000000000000000000000000000000000000933150f50b442408b5dfe1f3e0c7", + "0x000000000000000000000000000000c7a66235a171e2811d14e67fd0c3b5b956", + "0x000000000000000000000000000000000021a2a5436d34619b6d7e81bdd15cac", + "0x0000000000000000000000000000000e28a0630f5700ff16e99f46eae3403971", + "0x00000000000000000000000000000000000d16f238376b89d95c1f68dcae0454", + "0x0000000000000000000000000000007382cad6b54f2fb22f975d76efb0b81c49", + "0x000000000000000000000000000000000002e9b460093f90928ee18be9539629", + "0x000000000000000000000000000000c5e2e1eba84593c3974b0dba435b9d8f21", + "0x00000000000000000000000000000000000a1153cbb033dc5e2442c57cd4b5ac", + "0x000000000000000000000000000000128b93832bb99e1fc30eb659bb1f12de10", + "0x000000000000000000000000000000000014f6f3b35434f2ec365e5af8f5a48b", + "0x00000000000000000000000000000065273bd1933d4a63b541cc5354fd5d4373", + "0x00000000000000000000000000000000001caebff6fffa1d592accd502bdb7fb", + "0x000000000000000000000000000000b8dd3bd4a4cd0be01872d571f052dc46d6", + "0x00000000000000000000000000000000001aa7e1f4391a8bd527a8acf40043b0", + "0x0000000000000000000000000000006e5bf0f133423c77a7087658f993d00385", + "0x000000000000000000000000000000000017b27b225edc7df32ba6cc84b51cb2", + "0x00000000000000000000000000000036eb980311730f58f612deb101f9412df5", + "0x0000000000000000000000000000000000000e2664d7371b1b9364965876b56b", + "0x000000000000000000000000000000f9c31157b034c0997d71ccea0d28786c1c", + "0x00000000000000000000000000000000000a8006c31672351b08357625f0a471", + "0x000000000000000000000000000000f375c71b6d5cdb28f19b1ba2114ddb6983", + "0x000000000000000000000000000000000006a3614fa0dcaab2e8cf7fadd6687d", + "0x0000000000000000000000000000003d0d74919860ea101002fb3f240d206037", + "0x0000000000000000000000000000000000292827151f406fa7fc8c7af0ddb945", + "0x000000000000000000000000000000e4b984d5524e3603b6be2d74151c4d5726", + "0x00000000000000000000000000000000001bd0e811be863de0320210450fce89", + "0x000000000000000000000000000000ff5983ab316e997a671309660721bca669", + "0x0000000000000000000000000000000000155c3a8f63cafaeb9e98021d6f9427", + "0x00000000000000000000000000000015412a7441c03ad14362c7294bb6ef0509", + "0x00000000000000000000000000000000001513442f916c36196b3b24f5754fc5", + "0x000000000000000000000000000000755c5d5d06aec5cee2dd5c0e42f4dbdefa", + "0x00000000000000000000000000000000002551ff5c72c19fcabc8e6333a439a9", + "0x000000000000000000000000000000737d53ea6c25fe68fefe463a6d34fe8060", + "0x000000000000000000000000000000000027cfa68801ec744a103dbf2ed5fd1c" ] - hash = "0x23038e9c150580495cc7acd85a02a273bf3431573ec9c266d6f2982af4e0dcf1" + hash = "0x0e32b8d6a50ee381d8f7b95ec25454fbe007b2ebecf6c32b5e6179847e9cd080" -[inputs.hints] -previous_archive_sibling_path = [ - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb", - "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d", - "0x09308d0807f5aed64dd43d2014519a161c32f9a52ea75992cc18bec0bcde410e", - "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da", - "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249", - "0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f", - "0x221cf368938c74e4fced9dfb2a8e37cd8a6c57d21385c249f0b5c2412341287f", - "0x2c5214dfc4d70d2619fce2a7e02ddcf380576dca42b66c9215c7d8d1ec154116", - "0x13abc9bba431e6930c169f5daeb60aedbb27d7618c7ff88b3b4ec1c6de1d6bb8", - "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f", - "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad", - "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da", - "0x1077e8e59029b12e321c47a8a2a25283e50664b6ca1dd766a83828ddc6a22bb9", - "0x15b7bb46f75a6826da53df52c290eda3ddea8924becad6e9a3c08e4eb9a6f604", - "0x0f092097aaee3e41e55706add0701d0eff7a0c972a909dcbc915a478cbc8f122", - "0x2cf33c7d57e1ff8f3d98aabae3092befa8e92274da5e6d324ba0b8839889d27c", - "0x137e350aaf8bab893d768cb6e14bc5464877833efbb8c7091da9ecc7a96bc7b7", - "0x016505cc51b09b257b8c96b5fb20e90bd9e68416286a904d9f86b805e5a89e13", - "0x04d6e1009a70843f5bad89c59765d09421aad04e3276fc90f2a459565057978a", - "0x093a8215cd7e725a45949f4d6d4faec9d078221f09d26a27d61e4f0bf670a580", - "0x1704545cd66b0aa172d2c355fac161d17d7ea42f0132d24708762b544fa17357", - "0x2db6ed73abe6fc42bde50d4422c3e0c81def268d702b9256b7e67cafbbd0325c", - "0x21868e4f8cdcbcb9754d297edc2a361754517465c469017e784a4347f9eb6644", - "0x1adbb821ee5346b1979da8ddbb58789f5ef90c31ece8f0c543c221a3ef0f0aed", - "0x2058aa06a8e23bc53a625831ce1df1aa8d8f01924ad840607f33805aee179d90", - "0x1002be9f0852a234617c837e49555e328bb19a71fcea0ff34368901cee52c85e", - "0x2b238a0d25b834a061e45d817289ab221d13fd0e4cc7adf72d91d54c280f1aa0", - "0x15fada375c113bd526097e297b422ffb59f54a5451e5b70d4a4b028dc65208d1", - "0x2aad701e57c7069cb4e148d971c0eae9ac7429d7d833c51d87875ead0c5aca3c" -] -new_out_hash_sibling_path = [ - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x00f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb", - "0x0007638bb56b6dda2b64b8f76841114ac3a87a1820030e2e16772c4d294879c3", - "0x00efcbdb79553ae6863646bf36441755bc344a9a4af335fadc6659594faa4316", - "0x00089a9d421a82c4a25f7acbebe69e638d5b064fa8a60e018793dcb0be53752c" -] -blobs_fields = [ - "0x00000000009c70751800000003000000010001000f0000000000670000000080", - "0x1d5eca2c8752fa06d9d1ecd4578d2199986802a4fa302e01dee816659b53c8de", - "0x00000000000000000000000000000000000000000000000000198e45581dc500", - "0x12d1a8f339ac9b30aa47bf7c00ed478423d06e8a4e568bd827fc8104d901ca05", - "0x2e3af71b5fe34cd92094dd31931363f24ff8f759742d09a216d636de4c7e0323", - "0x277b1930c96a4771d7d1c33b7d19eff1b3a47fce3a328b55a2a4caadc7fc74bd", - "0x061ad0f0ed7065820b58cc64574e3bf863d19f7b368dc6d3594bc21208d48f6f", - "0x00000000000000000000000000000000000000000000021e0a6a3c99fb198000", - "0x000000000000000000000000000000000000000000000000000000000000000f", - "0x1a7e1badb79abdd38c684b3c8306ffe7ecb33c69e3380d9855730aaaa83a21a8", - "0x25f1be81a0ae9f7adc0506c721cfc092cececc837fd115cb16a60e8247d6312b", - "0x0000000000000000000000000000000000000000000000000000000000000002", - "0x1e495537a58fe255952a20bc319ebbf9d5eb2bc2692addbee2f6f97f946eae28", - "0x1e492f3e5b963534b5812a7e1e704db89c5265ff507aee8ff96a27154525c44d", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x14fbaeaeddaa69be81d404c684e78e9f1a786d225faf8de2ce97c92f67d89a26", - "0x00c044b05b6ca83b9c2dbae79cc1135155956a64e136819136e9947fe5e5866c", - "0x1c1f0ca244c7cd46b682552bff8ae77dea40b966a71de076ec3b7678f2bdb151", - "0x0e60ed663a4da5636e2e25a1f1f0c5b27c011c8eaed22bbe61e2a0fd875dd24b", - "0x082c6d164b0ba073c9dd911100248c8ecd80b03f82f38531856a3c16dadcbef0", - "0x14a5d4bde495b8c3a9ba4aed0d4870526e46fdff22d341a2f689ac5a50d10356", - "0x0f124f07811eebfaaa6d31316a2cc5bf255fa118f720e8ff1f2fc0d4aa46d496", - "0x2deebd90399de05cddcd37661b24bdb4acd97dfd9faccc3a82543732d8f33e93", - "0x0000000000000000000000000000000000000000000000000000000000000001", - "0x20f5895a4e837356c2d551743df6bf642756dcd93cd31cbd37c556c90bf7f244", - "0x1e492f3e5b963534b5812a7e1e704db89c5265ff507aee8ff96a27154525c44d", +[inputs.inbox_parity] +proof = [ "0x0000000000000000000000000000000000000000000000000000000000000001", - "0x1a46c5781598e4074ebb3bababaee59adf89f1c84cffe38a4e814818f1c2ad27", - "0x2501a258c0ca8b1e06c26e9949c9e935d5e3240d83fb04d725d2e9da233c2382", - "0x0000000000000000000000000000000000000000000000000000000000000bb8", - "0x0027000204012800000104804527000004452500000041270203040127020404", - "0x00001f0a0003000400442d084402250000004b270202044527020304003b0e00", - "0x000300022900004304ffffffff262902000300a5a0df610a2a02030427020304", - "0x0001240200040000006b230000012f2d08010427020504020008010501270304", - "0x00040100220402051f3a000300030005002a0403052d0b05051e020004001e02", - "0x000004001e02000403002a0504061e02000404002a0604051e020004051c0a04", - "0x000600002a0506041e020005061c0a050600002a040605270206040127020804", - "0x0003002a0608072d0801040008010701270304040100220402072d0e06070022", - "0x000702072d0e06072702070403002a0407062d0a06072d0e050700220402062d", - "0x000b06062702070403002a0407053b0e00060005230000012f2902000400eb1e", - "0x0033420a2a020405270206000127020700002702080402240200050000015923", - "0x00000002542d08010527020904020008010901270305040100220502091f3a00", - "0x000300030009002a0503092d0b09091e020005001e02000500300a0009000627", - "0x00020a040227020c0403002a0a0c0b2d0801050008010b012703050401002205", - "0x00020b2d0e0a0b00220b020b2d0e0a0b27020b0403002a050b0a2d0a0a0b2d0e", - "0x00070b00220b020b2d0e090b002205020b2d0b0b0b27020c0403002a050c0a37", - "0x000e000b000a27020a040127020c0403002a0a0c0b2d0801050008010b012703", - "0x00050401002205020b2d0e0a0b00220b020b2d0e0a0b27020b0403002a050b0a", - "0x002d0a0a0b2d0e090b002205020a2d0b0a0a27020b0403002a050b093b0e000a", - "0x0000092300000254290200050022538df70a2a020509240200090000026f2300", - "0x0000037c2d08010527020904020008010901270305040100220502091f3a0003", - "0x0000030009002a0503092d0b09091e020005001e020005001e020005002f2a00", - "0x00060005000a002a0a0905300a0005000627020a040227020c0403002a0a0c0b", - "0x002d0801050008010b012703050401002205020b2d0e0a0b00220b020b2d0e0a", - "0x000b27020b0403002a050b0a2d0a0a0b2d0e070b00220b020b2d0e090b002205", - "0x00020b2d0b0b0b27020c0403002a050c0a370e000b000a27020a040127020c04", - "0x0003002a0a0c0b2d0801050008010b012703050401002205020b2d0e0a0b0022", - "0x000b020b2d0e0a0b27020b0403002a050b0a2d0a0a0b2d0e090b002205020a2d", - "0x000b0a0a27020b0403002a050b093b0e000a0009230000037c2902000500f0a3", - "0x004f5f0a2a02050927020a001427020c040227020e0403002a0c0e0d2d08010b", - "0x000008010d0127030b040100220b020d2d0e0c0d00220d020d2d0e0c0d27020d", - "0x000403002a0b0d0c2d0a0c0d2d0e070d00220d020d2d0e0a0d27020c04002702", - "0x000e0403002a0c0e0d2d0801070008010d012703070401002207020d2d0e0c0d", - "0x0000220d020d2d0e0c0d27020d0403002a070d0c27020c000a2d08010d27020e", - "0x0004030008010e0127030d040100220d020e2d0a0e0f2d0e040f00220f020f2d", - "0x000e0c0f2702040400240200090000045223000005a91e020009001e02000c00", - "0x002d0b0d0c00220c020c2d0e0c0d00220d020c3903a00043004300090008000c", - "0x00200200092102000c2d08010f27020e040000220f02112d0b11112702120403", - "0x00002a0f1210223a000c000400102d0a0c1127030f040100220f02122d0e1112", - "0x0000221202122d0e11122702130403002a111312000801120127021204002d0a", - "0x00111306221302130a2a0e121424020014000004f52d0a0e0e23000004f92d0a", - "0x00130e24020014000005130a2a0e131524020015000005132500000b74240200", - "0x00090000053c230000052000220f020c2d0b0c0c2702100403002a0f10093c0e", - "0x000c09230000053c0a2a0e0309240200090000055227020c04003c060c01300a", - "0x00000a00062d0b0b0900220902092d0e090b00220b020c2d0b0c0c27020e0403", - "0x00002a0b0e09370e000c00092d0b070900220902092d0e0907002207020c2d0b", - "0x000c0c27020e0403002a070e093b0e000c000923000005a92902000900a5f91f", - "0x00690a2a02090c2402000c000005c4230000071b1e02000c001e02000e00300a", - "0x00000a00062d0b0b0e00220e020e2d0e0e0b00220b020f2d0b0f0f2702100403", - "0x00002a0b100e370e000f000e2d0b0d0e00220e020e2d0e0e0d00220d020e3903", - "0x00a000430043000c0008000e2002000c2102000d2d08010f27020e040000220f", - "0x0002112d0b11112702120403002a0f1210223a000d000400102d0a0d1127030f", - "0x00040100220f02122d0e111200221202122d0e11122702130403002a11131200", - "0x000801120127021204002d0a111306221302130a2a0e12142402001400000693", - "0x002d0a0e0e23000006972d0a130e24020014000006b10a2a0e13152402001500", - "0x000006b12500000b742402000c000006da23000006be00220f020d2d0b0d0d27", - "0x0002100403002a0f100c3c0e0d0c23000006da0a2a0e030c2402000c000006f0", - "0x0027020d04003c060d012d0b070c00220c020c2d0e0c07002207020d2d0b0d0d", - "0x0027020e0403002a070e0c3b0e000d000c230000071b2902000c008aec94960a", - "0x002a020c0d2402000d0000073623000009a91e02000c001e02000d002d08010d", - "0x0027020e04020008010e0127030d040100220d020e2d0a0e0f2d0e050f00220d", - "0x0002053903a000430043000c00030005200200052102000d2d08010f27020e04", - "0x000000220f02112d0b11112702120403002a0f1210223a000d000400102d0a0d", - "0x001127030f040100220f02122d0e111200221202122d0e11122702130403002a", - "0x00111312000801120127021204002d0a111306221302130a2a0e121424020014", - "0x00000007ec2d0a0e0e23000007f02d0a130e240200140000080a0a2a0e131524", - "0x000200150000080a2500000b742402000500000833230000081700220f020d2d", - "0x000b0d0d2702100403002a0f10053c0e0d0523000008330a2a0e040524020005", - "0x000000084927020d04003c060d012d08010527020d04020008010d0127030504", - "0x0001002205020d2d0a0d0e2d0e090e00220502093903a000430043000c000300", - "0x000920020003210200052d08010c270209040000220c020e2d0b0e0e27020f04", - "0x0003002a0c0f0d223a00050004000d2d0a050e27030c040100220c020f2d0e0e", - "0x000f00220f020f2d0e0e0f2702100403002a0e100f0008010f0127020f04002d", - "0x000a0e1006221002100a2a090f1124020011000008f52d0a090923000008f92d", - "0x000a100924020011000009130a2a09101224020012000009132500000b742402", - "0x0000030000093c230000092000220c02052d0b050527020d0403002a0c0d033c", - "0x000e0503230000093c0a2a090403240200030000095227020504003c06050130", - "0x000a000a00062d0b0b0300220302032d0e030b00220b02052d0b050527020904", - "0x0003002a0b0903370e000500032d0b070300220302032d0e030700220702052d", - "0x000b05052702080403002a0708033b0e0005000323000009a927020302552702", - "0x0004026e270205026b270207026f2702080277270209022027020a027327020b", - "0x00026527020c026c27020d026327020e027427020f0272270210027b27021102", - "0x007d2d080112270213041c0008011301270312040100221202132d0a13142d0e", - "0x00031400221402142d0e041400221402142d0e051400221402142d0e04140022", - "0x001402142d0e071400221402142d0e081400221402142d0e041400221402142d", - "0x000e091400221402142d0e0a1400221402142d0e0b1400221402142d0e0c1400", - "0x00221402142d0e0b1400221402142d0e0d1400221402142d0e0e140022140214", - "0x002d0e071400221402142d0e0f1400221402142d0e091400221402142d0e1014", - "0x0000221402142d0e0a1400221402142d0e0b1400221402142d0e0c1400221402", - "0x00142d0e0b1400221402142d0e0d1400221402142d0e0e1400221402142d0e07", - "0x001400221402142d0e0f1400221402142d0e1114270203010127020401000a2a", - "0x000403052402000500000b74270207041e2d080108270209041e00080109012d", - "0x000a08092a030009059b5bbff74a5bff190022090209002212020a27020b041b", - "0x002d020a032d0209042d020b052500000b8627020a041b002a090a092d0e0609", - "0x0000220902092d0e020900220902093c0e07082a0100010575fef108377c8a4f", - "0x003c0402012600000305072d0003082d0004092300000baa2d0108062d040609", - "0x00000008020800000902090c0008070a2400000a00000b982600000000000000", - "0x0000000000000000000000000000eb8dcdbf000000006a4d22fd000000090001", - "0x000000000000000001c00000000006000000000200000000008b00000008992c", - "0x1842a814b068f699565f4df77ab9139f1cfab687ef959bf92ba0bb3adf93d8dd", - "0x034b30004686b0cbe57927eaa548af4a428eabee71f4e3e8a581a43084facde5", - "0x00260be7577812f167b02eb1c2fa10efc5f169fe19845ada374d4c1518af35f4", - "0x2536a3212b711359308d274b8a92fa44465b6ce091dd9369c1331f1ffdeaa8ca", - "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a", - "0x0000000000000000000000000000000000000000000000008c63744300000088", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000002", + "0x0000000000000000000000000000000000000000000000000000000000000003", + "0x0000000000000000000000000000000000000000000000000000000000000004", + "0x0000000000000000000000000000000000000000000000000000000000000005", + "0x0000000000000000000000000000000000000000000000000000000000000006", + "0x0000000000000000000000000000000000000000000000000000000000000007", + "0x0000000000000000000000000000000000000000000000000000000000000008", + "0x0000000000000000000000000000000000000000000000000000000000000009", + "0x000000000000000000000000000000000000000000000000000000000000000a", + "0x000000000000000000000000000000000000000000000000000000000000000b", + "0x000000000000000000000000000000000000000000000000000000000000000c", + "0x000000000000000000000000000000000000000000000000000000000000000d", + "0x000000000000000000000000000000000000000000000000000000000000000e", + "0x000000000000000000000000000000000000000000000000000000000000000f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x0000000000000000000000000000000000000000000000000000000000000011", + "0x0000000000000000000000000000000000000000000000000000000000000012", + "0x0000000000000000000000000000000000000000000000000000000000000013", + "0x0000000000000000000000000000000000000000000000000000000000000014", + "0x0000000000000000000000000000000000000000000000000000000000000015", + "0x0000000000000000000000000000000000000000000000000000000000000016", + "0x0000000000000000000000000000000000000000000000000000000000000017", + "0x0000000000000000000000000000000000000000000000000000000000000018", + "0x0000000000000000000000000000000000000000000000000000000000000019", + "0x000000000000000000000000000000000000000000000000000000000000001a", + "0x000000000000000000000000000000000000000000000000000000000000001b", + "0x000000000000000000000000000000000000000000000000000000000000001c", + "0x000000000000000000000000000000000000000000000000000000000000001d", + "0x000000000000000000000000000000000000000000000000000000000000001e", + "0x000000000000000000000000000000000000000000000000000000000000001f", + "0x0000000000000000000000000000000000000000000000000000000000000020", + "0x0000000000000000000000000000000000000000000000000000000000000021", + "0x0000000000000000000000000000000000000000000000000000000000000022", + "0x0000000000000000000000000000000000000000000000000000000000000023", + "0x0000000000000000000000000000000000000000000000000000000000000024", + "0x0000000000000000000000000000000000000000000000000000000000000025", + "0x0000000000000000000000000000000000000000000000000000000000000026", + "0x0000000000000000000000000000000000000000000000000000000000000027", + "0x0000000000000000000000000000000000000000000000000000000000000028", + "0x0000000000000000000000000000000000000000000000000000000000000029", + "0x000000000000000000000000000000000000000000000000000000000000002a", + "0x000000000000000000000000000000000000000000000000000000000000002b", + "0x000000000000000000000000000000000000000000000000000000000000002c", + "0x000000000000000000000000000000000000000000000000000000000000002d", + "0x000000000000000000000000000000000000000000000000000000000000002e", + "0x000000000000000000000000000000000000000000000000000000000000002f", + "0x0000000000000000000000000000000000000000000000000000000000000030", + "0x0000000000000000000000000000000000000000000000000000000000000031", + "0x0000000000000000000000000000000000000000000000000000000000000032", + "0x0000000000000000000000000000000000000000000000000000000000000033", + "0x0000000000000000000000000000000000000000000000000000000000000034", + "0x0000000000000000000000000000000000000000000000000000000000000035", + "0x0000000000000000000000000000000000000000000000000000000000000036", + "0x0000000000000000000000000000000000000000000000000000000000000037", + "0x0000000000000000000000000000000000000000000000000000000000000038", + "0x0000000000000000000000000000000000000000000000000000000000000039", + "0x000000000000000000000000000000000000000000000000000000000000003a", + "0x000000000000000000000000000000000000000000000000000000000000003b", + "0x000000000000000000000000000000000000000000000000000000000000003c", + "0x000000000000000000000000000000000000000000000000000000000000003d", + "0x000000000000000000000000000000000000000000000000000000000000003e", + "0x000000000000000000000000000000000000000000000000000000000000003f", + "0x0000000000000000000000000000000000000000000000000000000000000040", + "0x0000000000000000000000000000000000000000000000000000000000000041", + "0x0000000000000000000000000000000000000000000000000000000000000042", + "0x0000000000000000000000000000000000000000000000000000000000000043", + "0x0000000000000000000000000000000000000000000000000000000000000044", + "0x0000000000000000000000000000000000000000000000000000000000000045", + "0x0000000000000000000000000000000000000000000000000000000000000046", + "0x0000000000000000000000000000000000000000000000000000000000000047", + "0x0000000000000000000000000000000000000000000000000000000000000048", + "0x0000000000000000000000000000000000000000000000000000000000000049", + "0x000000000000000000000000000000000000000000000000000000000000004a", + "0x000000000000000000000000000000000000000000000000000000000000004b", + "0x000000000000000000000000000000000000000000000000000000000000004c", + "0x000000000000000000000000000000000000000000000000000000000000004d", + "0x000000000000000000000000000000000000000000000000000000000000004e", + "0x000000000000000000000000000000000000000000000000000000000000004f", + "0x0000000000000000000000000000000000000000000000000000000000000050", + "0x0000000000000000000000000000000000000000000000000000000000000051", + "0x0000000000000000000000000000000000000000000000000000000000000052", + "0x0000000000000000000000000000000000000000000000000000000000000053", + "0x0000000000000000000000000000000000000000000000000000000000000054", + "0x0000000000000000000000000000000000000000000000000000000000000055", + "0x0000000000000000000000000000000000000000000000000000000000000056", + "0x0000000000000000000000000000000000000000000000000000000000000057", + "0x0000000000000000000000000000000000000000000000000000000000000058", + "0x0000000000000000000000000000000000000000000000000000000000000059", + "0x000000000000000000000000000000000000000000000000000000000000005a", + "0x000000000000000000000000000000000000000000000000000000000000005b", + "0x000000000000000000000000000000000000000000000000000000000000005c", + "0x000000000000000000000000000000000000000000000000000000000000005d", + "0x000000000000000000000000000000000000000000000000000000000000005e", + "0x000000000000000000000000000000000000000000000000000000000000005f", + "0x0000000000000000000000000000000000000000000000000000000000000060", + "0x0000000000000000000000000000000000000000000000000000000000000061", + "0x0000000000000000000000000000000000000000000000000000000000000062", + "0x0000000000000000000000000000000000000000000000000000000000000063", + "0x0000000000000000000000000000000000000000000000000000000000000064", + "0x0000000000000000000000000000000000000000000000000000000000000065", + "0x0000000000000000000000000000000000000000000000000000000000000066", + "0x0000000000000000000000000000000000000000000000000000000000000067", + "0x0000000000000000000000000000000000000000000000000000000000000068", + "0x0000000000000000000000000000000000000000000000000000000000000069", + "0x000000000000000000000000000000000000000000000000000000000000006a", + "0x000000000000000000000000000000000000000000000000000000000000006b", + "0x000000000000000000000000000000000000000000000000000000000000006c", + "0x000000000000000000000000000000000000000000000000000000000000006d", + "0x000000000000000000000000000000000000000000000000000000000000006e", + "0x000000000000000000000000000000000000000000000000000000000000006f", + "0x0000000000000000000000000000000000000000000000000000000000000070", + "0x0000000000000000000000000000000000000000000000000000000000000071", + "0x0000000000000000000000000000000000000000000000000000000000000072", + "0x0000000000000000000000000000000000000000000000000000000000000073", + "0x0000000000000000000000000000000000000000000000000000000000000074", + "0x0000000000000000000000000000000000000000000000000000000000000075", + "0x0000000000000000000000000000000000000000000000000000000000000076", + "0x0000000000000000000000000000000000000000000000000000000000000077", + "0x0000000000000000000000000000000000000000000000000000000000000078", + "0x0000000000000000000000000000000000000000000000000000000000000079", + "0x000000000000000000000000000000000000000000000000000000000000007a", + "0x000000000000000000000000000000000000000000000000000000000000007b", + "0x000000000000000000000000000000000000000000000000000000000000007c", + "0x000000000000000000000000000000000000000000000000000000000000007d", + "0x000000000000000000000000000000000000000000000000000000000000007e", + "0x000000000000000000000000000000000000000000000000000000000000007f", + "0x0000000000000000000000000000000000000000000000000000000000000080", + "0x0000000000000000000000000000000000000000000000000000000000000081", + "0x0000000000000000000000000000000000000000000000000000000000000082", + "0x0000000000000000000000000000000000000000000000000000000000000083", + "0x0000000000000000000000000000000000000000000000000000000000000084", + "0x0000000000000000000000000000000000000000000000000000000000000085", + "0x0000000000000000000000000000000000000000000000000000000000000086", + "0x0000000000000000000000000000000000000000000000000000000000000087", + "0x0000000000000000000000000000000000000000000000000000000000000088", + "0x0000000000000000000000000000000000000000000000000000000000000089", + "0x000000000000000000000000000000000000000000000000000000000000008a", + "0x000000000000000000000000000000000000000000000000000000000000008b", + "0x000000000000000000000000000000000000000000000000000000000000008c", + "0x000000000000000000000000000000000000000000000000000000000000008d", + "0x000000000000000000000000000000000000000000000000000000000000008e", + "0x000000000000000000000000000000000000000000000000000000000000008f", + "0x0000000000000000000000000000000000000000000000000000000000000090", + "0x0000000000000000000000000000000000000000000000000000000000000091", + "0x0000000000000000000000000000000000000000000000000000000000000092", + "0x0000000000000000000000000000000000000000000000000000000000000093", + "0x0000000000000000000000000000000000000000000000000000000000000094", + "0x0000000000000000000000000000000000000000000000000000000000000095", + "0x0000000000000000000000000000000000000000000000000000000000000096", + "0x0000000000000000000000000000000000000000000000000000000000000097", + "0x0000000000000000000000000000000000000000000000000000000000000098", + "0x0000000000000000000000000000000000000000000000000000000000000099", + "0x000000000000000000000000000000000000000000000000000000000000009a", + "0x000000000000000000000000000000000000000000000000000000000000009b", + "0x000000000000000000000000000000000000000000000000000000000000009c", + "0x000000000000000000000000000000000000000000000000000000000000009d", + "0x000000000000000000000000000000000000000000000000000000000000009e", + "0x000000000000000000000000000000000000000000000000000000000000009f", + "0x00000000000000000000000000000000000000000000000000000000000000a0", + "0x00000000000000000000000000000000000000000000000000000000000000a1", + "0x00000000000000000000000000000000000000000000000000000000000000a2", + "0x00000000000000000000000000000000000000000000000000000000000000a3", + "0x00000000000000000000000000000000000000000000000000000000000000a4", + "0x00000000000000000000000000000000000000000000000000000000000000a5", + "0x00000000000000000000000000000000000000000000000000000000000000a6", + "0x00000000000000000000000000000000000000000000000000000000000000a7", + "0x00000000000000000000000000000000000000000000000000000000000000a8", + "0x00000000000000000000000000000000000000000000000000000000000000a9", + "0x00000000000000000000000000000000000000000000000000000000000000aa", + "0x00000000000000000000000000000000000000000000000000000000000000ab", + "0x00000000000000000000000000000000000000000000000000000000000000ac", + "0x00000000000000000000000000000000000000000000000000000000000000ad", + "0x00000000000000000000000000000000000000000000000000000000000000ae", + "0x00000000000000000000000000000000000000000000000000000000000000af", + "0x00000000000000000000000000000000000000000000000000000000000000b0", + "0x00000000000000000000000000000000000000000000000000000000000000b1", + "0x00000000000000000000000000000000000000000000000000000000000000b2", + "0x00000000000000000000000000000000000000000000000000000000000000b3", + "0x00000000000000000000000000000000000000000000000000000000000000b4", + "0x00000000000000000000000000000000000000000000000000000000000000b5", + "0x00000000000000000000000000000000000000000000000000000000000000b6", + "0x00000000000000000000000000000000000000000000000000000000000000b7", + "0x00000000000000000000000000000000000000000000000000000000000000b8", + "0x00000000000000000000000000000000000000000000000000000000000000b9", + "0x00000000000000000000000000000000000000000000000000000000000000ba", + "0x00000000000000000000000000000000000000000000000000000000000000bb", + "0x00000000000000000000000000000000000000000000000000000000000000bc", + "0x00000000000000000000000000000000000000000000000000000000000000bd", + "0x00000000000000000000000000000000000000000000000000000000000000be", + "0x00000000000000000000000000000000000000000000000000000000000000bf", + "0x00000000000000000000000000000000000000000000000000000000000000c0", + "0x00000000000000000000000000000000000000000000000000000000000000c1", + "0x00000000000000000000000000000000000000000000000000000000000000c2", + "0x00000000000000000000000000000000000000000000000000000000000000c3", + "0x00000000000000000000000000000000000000000000000000000000000000c4", + "0x00000000000000000000000000000000000000000000000000000000000000c5", + "0x00000000000000000000000000000000000000000000000000000000000000c6", + "0x00000000000000000000000000000000000000000000000000000000000000c7", + "0x00000000000000000000000000000000000000000000000000000000000000c8", + "0x00000000000000000000000000000000000000000000000000000000000000c9", + "0x00000000000000000000000000000000000000000000000000000000000000ca", + "0x00000000000000000000000000000000000000000000000000000000000000cb", + "0x00000000000000000000000000000000000000000000000000000000000000cc", + "0x00000000000000000000000000000000000000000000000000000000000000cd", + "0x00000000000000000000000000000000000000000000000000000000000000ce", + "0x00000000000000000000000000000000000000000000000000000000000000cf", + "0x00000000000000000000000000000000000000000000000000000000000000d0", + "0x00000000000000000000000000000000000000000000000000000000000000d1", + "0x00000000000000000000000000000000000000000000000000000000000000d2", + "0x00000000000000000000000000000000000000000000000000000000000000d3", + "0x00000000000000000000000000000000000000000000000000000000000000d4", + "0x00000000000000000000000000000000000000000000000000000000000000d5", + "0x00000000000000000000000000000000000000000000000000000000000000d6", + "0x00000000000000000000000000000000000000000000000000000000000000d7", + "0x00000000000000000000000000000000000000000000000000000000000000d8", + "0x00000000000000000000000000000000000000000000000000000000000000d9", + "0x00000000000000000000000000000000000000000000000000000000000000da", + "0x00000000000000000000000000000000000000000000000000000000000000db", + "0x00000000000000000000000000000000000000000000000000000000000000dc", + "0x00000000000000000000000000000000000000000000000000000000000000dd", + "0x00000000000000000000000000000000000000000000000000000000000000de", + "0x00000000000000000000000000000000000000000000000000000000000000df", + "0x00000000000000000000000000000000000000000000000000000000000000e0", + "0x00000000000000000000000000000000000000000000000000000000000000e1", + "0x00000000000000000000000000000000000000000000000000000000000000e2", + "0x00000000000000000000000000000000000000000000000000000000000000e3", + "0x00000000000000000000000000000000000000000000000000000000000000e4", + "0x00000000000000000000000000000000000000000000000000000000000000e5", + "0x00000000000000000000000000000000000000000000000000000000000000e6", + "0x00000000000000000000000000000000000000000000000000000000000000e7", + "0x00000000000000000000000000000000000000000000000000000000000000e8", + "0x00000000000000000000000000000000000000000000000000000000000000e9", + "0x00000000000000000000000000000000000000000000000000000000000000ea", + "0x00000000000000000000000000000000000000000000000000000000000000eb", + "0x00000000000000000000000000000000000000000000000000000000000000ec", + "0x00000000000000000000000000000000000000000000000000000000000000ed", + "0x00000000000000000000000000000000000000000000000000000000000000ee", + "0x00000000000000000000000000000000000000000000000000000000000000ef", + "0x00000000000000000000000000000000000000000000000000000000000000f0", + "0x00000000000000000000000000000000000000000000000000000000000000f1", + "0x00000000000000000000000000000000000000000000000000000000000000f2", + "0x00000000000000000000000000000000000000000000000000000000000000f3", + "0x00000000000000000000000000000000000000000000000000000000000000f4", + "0x00000000000000000000000000000000000000000000000000000000000000f5", + "0x00000000000000000000000000000000000000000000000000000000000000f6", + "0x00000000000000000000000000000000000000000000000000000000000000f7", + "0x00000000000000000000000000000000000000000000000000000000000000f8", + "0x00000000000000000000000000000000000000000000000000000000000000f9", + "0x00000000000000000000000000000000000000000000000000000000000000fa", + "0x00000000000000000000000000000000000000000000000000000000000000fb", + "0x00000000000000000000000000000000000000000000000000000000000000fc", + "0x00000000000000000000000000000000000000000000000000000000000000fd", + "0x00000000000000000000000000000000000000000000000000000000000000fe", + "0x00000000000000000000000000000000000000000000000000000000000000ff", + "0x0000000000000000000000000000000000000000000000000000000000000100", + "0x0000000000000000000000000000000000000000000000000000000000000101", + "0x0000000000000000000000000000000000000000000000000000000000000102", + "0x0000000000000000000000000000000000000000000000000000000000000103", + "0x0000000000000000000000000000000000000000000000000000000000000104", + "0x0000000000000000000000000000000000000000000000000000000000000105", + "0x0000000000000000000000000000000000000000000000000000000000000106", + "0x0000000000000000000000000000000000000000000000000000000000000107", + "0x0000000000000000000000000000000000000000000000000000000000000108", + "0x0000000000000000000000000000000000000000000000000000000000000109", + "0x000000000000000000000000000000000000000000000000000000000000010a", + "0x000000000000000000000000000000000000000000000000000000000000010b", + "0x000000000000000000000000000000000000000000000000000000000000010c", + "0x000000000000000000000000000000000000000000000000000000000000010d", + "0x000000000000000000000000000000000000000000000000000000000000010e", + "0x000000000000000000000000000000000000000000000000000000000000010f", + "0x0000000000000000000000000000000000000000000000000000000000000110", + "0x0000000000000000000000000000000000000000000000000000000000000111", + "0x0000000000000000000000000000000000000000000000000000000000000112", + "0x0000000000000000000000000000000000000000000000000000000000000113", + "0x0000000000000000000000000000000000000000000000000000000000000114", + "0x0000000000000000000000000000000000000000000000000000000000000115", + "0x0000000000000000000000000000000000000000000000000000000000000116", + "0x0000000000000000000000000000000000000000000000000000000000000117", + "0x0000000000000000000000000000000000000000000000000000000000000118", + "0x0000000000000000000000000000000000000000000000000000000000000119", + "0x000000000000000000000000000000000000000000000000000000000000011a", + "0x000000000000000000000000000000000000000000000000000000000000011b", + "0x000000000000000000000000000000000000000000000000000000000000011c", + "0x000000000000000000000000000000000000000000000000000000000000011d", + "0x000000000000000000000000000000000000000000000000000000000000011e", + "0x000000000000000000000000000000000000000000000000000000000000011f", + "0x0000000000000000000000000000000000000000000000000000000000000120", + "0x0000000000000000000000000000000000000000000000000000000000000121", + "0x0000000000000000000000000000000000000000000000000000000000000122", + "0x0000000000000000000000000000000000000000000000000000000000000123", + "0x0000000000000000000000000000000000000000000000000000000000000124", + "0x0000000000000000000000000000000000000000000000000000000000000125", + "0x0000000000000000000000000000000000000000000000000000000000000126", + "0x0000000000000000000000000000000000000000000000000000000000000127", + "0x0000000000000000000000000000000000000000000000000000000000000128", + "0x0000000000000000000000000000000000000000000000000000000000000129", + "0x000000000000000000000000000000000000000000000000000000000000012a", + "0x000000000000000000000000000000000000000000000000000000000000012b", + "0x000000000000000000000000000000000000000000000000000000000000012c", + "0x000000000000000000000000000000000000000000000000000000000000012d", + "0x000000000000000000000000000000000000000000000000000000000000012e", + "0x000000000000000000000000000000000000000000000000000000000000012f", + "0x0000000000000000000000000000000000000000000000000000000000000130", + "0x0000000000000000000000000000000000000000000000000000000000000131", + "0x0000000000000000000000000000000000000000000000000000000000000132", + "0x0000000000000000000000000000000000000000000000000000000000000133", + "0x0000000000000000000000000000000000000000000000000000000000000134", + "0x0000000000000000000000000000000000000000000000000000000000000135", + "0x0000000000000000000000000000000000000000000000000000000000000136", + "0x0000000000000000000000000000000000000000000000000000000000000137", + "0x0000000000000000000000000000000000000000000000000000000000000138", + "0x0000000000000000000000000000000000000000000000000000000000000139", + "0x000000000000000000000000000000000000000000000000000000000000013a", + "0x000000000000000000000000000000000000000000000000000000000000013b", + "0x000000000000000000000000000000000000000000000000000000000000013c", + "0x000000000000000000000000000000000000000000000000000000000000013d", + "0x000000000000000000000000000000000000000000000000000000000000013e", + "0x000000000000000000000000000000000000000000000000000000000000013f", + "0x0000000000000000000000000000000000000000000000000000000000000140", + "0x0000000000000000000000000000000000000000000000000000000000000141", + "0x0000000000000000000000000000000000000000000000000000000000000142", + "0x0000000000000000000000000000000000000000000000000000000000000143", + "0x0000000000000000000000000000000000000000000000000000000000000144", + "0x0000000000000000000000000000000000000000000000000000000000000145", + "0x0000000000000000000000000000000000000000000000000000000000000146", + "0x0000000000000000000000000000000000000000000000000000000000000147", + "0x0000000000000000000000000000000000000000000000000000000000000148", + "0x0000000000000000000000000000000000000000000000000000000000000149", + "0x000000000000000000000000000000000000000000000000000000000000014a", + "0x000000000000000000000000000000000000000000000000000000000000014b", + "0x000000000000000000000000000000000000000000000000000000000000014c", + "0x000000000000000000000000000000000000000000000000000000000000014d", + "0x000000000000000000000000000000000000000000000000000000000000014e", + "0x000000000000000000000000000000000000000000000000000000000000014f", + "0x0000000000000000000000000000000000000000000000000000000000000150", + "0x0000000000000000000000000000000000000000000000000000000000000151", + "0x0000000000000000000000000000000000000000000000000000000000000152", + "0x0000000000000000000000000000000000000000000000000000000000000153", + "0x0000000000000000000000000000000000000000000000000000000000000154", + "0x0000000000000000000000000000000000000000000000000000000000000155", + "0x0000000000000000000000000000000000000000000000000000000000000156", + "0x0000000000000000000000000000000000000000000000000000000000000157", + "0x0000000000000000000000000000000000000000000000000000000000000158", + "0x0000000000000000000000000000000000000000000000000000000000000159", + "0x000000000000000000000000000000000000000000000000000000000000015a", + "0x000000000000000000000000000000000000000000000000000000000000015b", + "0x000000000000000000000000000000000000000000000000000000000000015c", + "0x000000000000000000000000000000000000000000000000000000000000015d", + "0x000000000000000000000000000000000000000000000000000000000000015e", + "0x000000000000000000000000000000000000000000000000000000000000015f", + "0x0000000000000000000000000000000000000000000000000000000000000160", + "0x0000000000000000000000000000000000000000000000000000000000000161", + "0x0000000000000000000000000000000000000000000000000000000000000162", + "0x0000000000000000000000000000000000000000000000000000000000000163", + "0x0000000000000000000000000000000000000000000000000000000000000164", + "0x0000000000000000000000000000000000000000000000000000000000000165", + "0x0000000000000000000000000000000000000000000000000000000000000166", + "0x0000000000000000000000000000000000000000000000000000000000000167", + "0x0000000000000000000000000000000000000000000000000000000000000168", + "0x0000000000000000000000000000000000000000000000000000000000000169", + "0x000000000000000000000000000000000000000000000000000000000000016a", + "0x000000000000000000000000000000000000000000000000000000000000016b", + "0x000000000000000000000000000000000000000000000000000000000000016c", + "0x000000000000000000000000000000000000000000000000000000000000016d", + "0x000000000000000000000000000000000000000000000000000000000000016e", + "0x000000000000000000000000000000000000000000000000000000000000016f", + "0x0000000000000000000000000000000000000000000000000000000000000170", + "0x0000000000000000000000000000000000000000000000000000000000000171", + "0x0000000000000000000000000000000000000000000000000000000000000172", + "0x0000000000000000000000000000000000000000000000000000000000000173", + "0x0000000000000000000000000000000000000000000000000000000000000174", + "0x0000000000000000000000000000000000000000000000000000000000000175", + "0x0000000000000000000000000000000000000000000000000000000000000176", + "0x0000000000000000000000000000000000000000000000000000000000000177", + "0x0000000000000000000000000000000000000000000000000000000000000178", + "0x0000000000000000000000000000000000000000000000000000000000000179", + "0x000000000000000000000000000000000000000000000000000000000000017a", + "0x000000000000000000000000000000000000000000000000000000000000017b", + "0x000000000000000000000000000000000000000000000000000000000000017c", + "0x000000000000000000000000000000000000000000000000000000000000017d", + "0x000000000000000000000000000000000000000000000000000000000000017e", + "0x000000000000000000000000000000000000000000000000000000000000017f", + "0x0000000000000000000000000000000000000000000000000000000000000180", + "0x0000000000000000000000000000000000000000000000000000000000000181", + "0x0000000000000000000000000000000000000000000000000000000000000182", + "0x0000000000000000000000000000000000000000000000000000000000000183", + "0x0000000000000000000000000000000000000000000000000000000000000184", + "0x0000000000000000000000000000000000000000000000000000000000000185", + "0x0000000000000000000000000000000000000000000000000000000000000186", + "0x0000000000000000000000000000000000000000000000000000000000000187", + "0x0000000000000000000000000000000000000000000000000000000000000188", + "0x0000000000000000000000000000000000000000000000000000000000000189", + "0x000000000000000000000000000000000000000000000000000000000000018a", + "0x000000000000000000000000000000000000000000000000000000000000018b", + "0x000000000000000000000000000000000000000000000000000000000000018c", + "0x000000000000000000000000000000000000000000000000000000000000018d", + "0x000000000000000000000000000000000000000000000000000000000000018e", + "0x000000000000000000000000000000000000000000000000000000000000018f", + "0x0000000000000000000000000000000000000000000000000000000000000190", + "0x0000000000000000000000000000000000000000000000000000000000000191", + "0x0000000000000000000000000000000000000000000000000000000000000192", + "0x0000000000000000000000000000000000000000000000000000000000000193", + "0x0000000000000000000000000000000000000000000000000000000000000194", + "0x0000000000000000000000000000000000000000000000000000000000000195", + "0x0000000000000000000000000000000000000000000000000000000000000196", + "0x0000000000000000000000000000000000000000000000000000000000000197", + "0x0000000000000000000000000000000000000000000000000000000000000198", + "0x0000000000000000000000000000000000000000000000000000000000000199", + "0x000000000000000000000000000000000000000000000000000000000000019a" +] + + [inputs.inbox_parity.public_inputs] + in_hash = "0x00aa91330eafec1db9b1ca2e1733b213a28bfde0499aca2506acc8c00aae7ba3" + start_rolling_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" + end_rolling_hash = "0x005b0c15d0f641e148adfec120a12eadbf8343e009d350aa593b6d78dbae9568" + num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400" + vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.inbox_parity.public_inputs.start_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.inbox_parity.public_inputs.start_sponge.sponge] + cache = [ "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + state = [ "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000000" + squeeze_mode = false + + [inputs.inbox_parity.public_inputs.end_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.inbox_parity.public_inputs.end_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" +] + state = [ + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false + + [inputs.inbox_parity.vk_data] + leaf_index = "0x000000000000000000000000000000000000000000000000000000000000004c" + sibling_path = [ "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb", + "0x00f0288e12c8d2cfc9a3367452f5cde532eb491b48a9973413f76776f21078d7", + "0x0a1d41f1f9a82ceedcca0a62137d817577e4ff56a352e1fcd6757134719f67df", + "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da", + "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249", + "0x1b82d88b0126f67d4dd805387fb3904a609c9926c1c9f3d4af2d35f6699dd2a8" +] + + [inputs.inbox_parity.vk_data.vk] + key = [ + "0x0000000000000000000000000000000000000000000000000000000000000018", + "0x0000000000000000000000000000000000000000000000000000000000000022", + "0x0000000000000000000000000000000000000000000000000000000000000005", + "0x000000000000000000000000000000328d1319c69d7e686b6ec27f5f8826f1d6", + "0x00000000000000000000000000000000001e5129f05687a0605e92998f362d22", + "0x00000000000000000000000000000016b8afcbfa53d116a63aa18f1305ac5354", + "0x0000000000000000000000000000000000010bb457863dd919b09ffa619278ec", + "0x0000000000000000000000000000000bc57f7730a7234dee675e439d79fdd3ff", + "0x00000000000000000000000000000000000eb3ccd01c8f9bcb569c3678b3bdd4", + "0x000000000000000000000000000000309d4a9ff9c28c81b3ab1ead81e118545a", + "0x000000000000000000000000000000000019e58c2c3d369fb0b5bd0ada5f1a52", + "0x00000000000000000000000000000032511092a06981ce1ac5cb12e6af8810db", + "0x00000000000000000000000000000000002184fb8c96926d717ac8356ef56911", + "0x0000000000000000000000000000000052f31cffba27db7a7697c73a687e798d", + "0x00000000000000000000000000000000000420a44a90550abe8a82948de4c5f5", + "0x000000000000000000000000000000552eb5ce6a1e83ee06636caea6a2505787", + "0x00000000000000000000000000000000001d68e034086c3bfc28287b93be153e", + "0x000000000000000000000000000000e6789f820241265c4a2ceb157cccda0a4f", + "0x00000000000000000000000000000000000ca13ea50c9c14bc0832b16a61e90e", + "0x000000000000000000000000000000407894f08a1839457acf02116214c13436", + "0x000000000000000000000000000000000014e7040f723b2fe2de9060a293d816", + "0x00000000000000000000000000000042387d2cd2b2664d10817060395f5f97d4", + "0x00000000000000000000000000000000000ff13eba3ce3e42ab168a243b27d82", + "0x000000000000000000000000000000e53814528e6d1e7d412387fca7d1f9b594", + "0x00000000000000000000000000000000002be14788e85833b10834b6e4d85ceb", + "0x00000000000000000000000000000034e2888e67d5cffdfb595c8e56b8595e63", + "0x0000000000000000000000000000000000209f3e0bd3ef2b680f2cd7b1e84e51", + "0x000000000000000000000000000000563cc437ecb7156ef5d87468328aaa0cb3", + "0x000000000000000000000000000000000001b5b362f9444dbfeed4f11bacd017", + "0x000000000000000000000000000000ffcf05ed417b3a4bdbe76a5da459d6c82a", + "0x00000000000000000000000000000000002b1da7f6e4bc380b6e35ca49bf5527", + "0x0000000000000000000000000000004dbda1adb8188198a8dcd576d6acd48378", + "0x000000000000000000000000000000000026b09aac709f7c50590491fe646cb6", + "0x0000000000000000000000000000009558d6fd4bdb0435ba53846c8074a6bf71", + "0x00000000000000000000000000000000002d71445044ebbba09bee463d922b78", + "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", + "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", + "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", + "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", + "0x0000000000000000000000000000007d31a1e637b282aecf3a21d0476e5ada2a", + "0x00000000000000000000000000000000000cb87f762b2b5e3f3883b73c1c8454", + "0x000000000000000000000000000000cc0ebf25502a79d92048e99b1f7bf6089a", + "0x000000000000000000000000000000000016200201ae31e2f019b766d6c6c77e", + "0x000000000000000000000000000000ece2ccc928bd0ce9dad4362e0ff8dd69cc", + "0x000000000000000000000000000000000022dc4262de0af1432a4df6b5c0d828", + "0x0000000000000000000000000000001bb52239fb6b68a03690884696453f7725", + "0x000000000000000000000000000000000009f7e8a07b29e1c775b23a666e1d51", + "0x00000000000000000000000000000087250a49d7a2c5e95c5cf96504c7afe932", + "0x00000000000000000000000000000000000be81f5f1e1a7a527d5ab9003aa9c6", + "0x0000000000000000000000000000007fd067241c9169a4c2d51ef5223f04145e", + "0x00000000000000000000000000000000000d62eec848241712d7a74b8a1b3c68", + "0x000000000000000000000000000000a8d2ca5f177c36c219084d36dddc000f83", + "0x00000000000000000000000000000000001cce6c20320da7875f350cf454cc22", + "0x0000000000000000000000000000001eae7070788b005571d12b3a540f96b382", + "0x000000000000000000000000000000000021075b87b825a098dea41fae4a52fc", + "0x00000000000000000000000000000009274d8a5dec6a4606f65d940398c4e84c", + "0x0000000000000000000000000000000000190ebd25195a9d0cc42aa520e32ca0", + "0x000000000000000000000000000000e4f823322afa50800d949ffeca1021b50f", + "0x0000000000000000000000000000000000180fd2df09a5c926d14d683ff7247e", + "0x000000000000000000000000000000f75f78af4ca6ab2b4d1d83ae42d23e6d42", + "0x0000000000000000000000000000000000052b59b0a3c352babfb2ca6fb2dc8b", + "0x000000000000000000000000000000bd2d6785d2f1f1fec8f475ddccefceec78", + "0x0000000000000000000000000000000000096d66f46432fc32317fb12bacbcb2", + "0x000000000000000000000000000000dc325a89c22b0408722be1f1c5785b1f4b", + "0x000000000000000000000000000000000019f69034db6803fd0bf6f717619077", + "0x0000000000000000000000000000002d7bd40a64f03f767a30f2e7fd018d5735", + "0x0000000000000000000000000000000000050d320c00614ec4c19f654d58cece", + "0x00000000000000000000000000000059676dcd87d84ba8724c46dc79d49f47a6", + "0x000000000000000000000000000000000017a1143cf04ef8e3e9a529f1b92770", + "0x000000000000000000000000000000a05aa46f97d4a0f1023bffcb1f77c1438b", + "0x00000000000000000000000000000000000b774fd8023d4876e999b647f05fef", + "0x000000000000000000000000000000a7b4b961805216a888251d68b551356964", + "0x0000000000000000000000000000000000123279dcabc48834b49734e9f2f8a0", + "0x0000000000000000000000000000001a3c5a4221ec46340509ea8b178cecdc08", + "0x0000000000000000000000000000000000288992bc430086e55d9d6cc5ce77ce", + "0x0000000000000000000000000000005409c9549e8beb1965faae93bcbe434daa", + "0x00000000000000000000000000000000002a0890a51aaa4b9f60aabb5bc60542", + "0x000000000000000000000000000000760859693aaf8991a597733a545ab431e6", + "0x00000000000000000000000000000000000f1c39c02aa1b7c229ec9b3eefc391", + "0x0000000000000000000000000000008b2b03962494b503a8ce86b3c232ea87cf", + "0x00000000000000000000000000000000003033c259bfdda849212c239228ee4a", + "0x00000000000000000000000000000030b30a8f93a50fcbc679a3d1168b294587", + "0x00000000000000000000000000000000001c39c0deb6b2b49105998bd64ff7ff", + "0x000000000000000000000000000000a6fa737b040db783952bd5cbdbc6ff0341", + "0x00000000000000000000000000000000002012e88d5d376500aba5240d8f37d4", + "0x000000000000000000000000000000993bb0aca115f36461afada9182663d04a", + "0x000000000000000000000000000000000016a501a6bd071fe93ec57bc01d09e9", + "0x0000000000000000000000000000008e99d84006eec3937117cd3dc54bf467bc", + "0x000000000000000000000000000000000026741ba7278d491cc4ef5f808fd3ed", + "0x00000000000000000000000000000059fd0a6d5caab12a3204ec2f3bb03ea273", + "0x00000000000000000000000000000000000c06a10d5a1f39c0d1ff01a8fedd52", + "0x00000000000000000000000000000087db338a273ef894bdee1298de59c7b9fc", + "0x000000000000000000000000000000000001bda0babe63bfbe1cc8170c26af48", + "0x00000000000000000000000000000076523a3d16889ef1b595d6ee771a54e4ba", + "0x00000000000000000000000000000000002ea89ff682b4d2427dd4ab430382ae", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000000000f93f9b3c3ccb03b1d0f59150699f9fa3f9", + "0x00000000000000000000000000000000001ae9fc694057698cfd927a9afe43fb", + "0x0000000000000000000000000000004baef7faea08dc749d788a4c6c9bbe29d2", + "0x00000000000000000000000000000000002cc1f10d4638983f558eecdc6ba39f", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000c2e566a842af127bb2863b28e5c9834dd", + "0x0000000000000000000000000000000000123326d1f3e3f1e6439701c2e4c376", + "0x0000000000000000000000000000001e726d0681305bc36d34999bc9848337c2", + "0x00000000000000000000000000000000001298212e7f4c6f496d44b34cf49805", + "0x000000000000000000000000000000d1ed1e54ab019bd2ca96095e6025ba414f", + "0x000000000000000000000000000000000019227b7d43eb104ef0e6acf3b0f41a", + "0x0000000000000000000000000000006692c1a1cfad8e8fac36fb92129878159f", + "0x00000000000000000000000000000000002e861c2b1aa417701f37425baa8d21" +] + hash = "0x09c1c633e0ec0baf5833b43503da14c2cbceaa66180315b0cab7fa5177337e0e" + +[inputs.hints] +previous_archive_sibling_path = [ "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb", + "0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d", + "0x30105bad22ddcc508b739b7c9ad87a561c569ff5cb0098a853c1c4ac21b7a037", + "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da", + "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249", + "0x119f56a2e8423a7feaab49b9b5dcbadec0648dfa4096b61b6774ea33ae29dc7f", + "0x221cf368938c74e4fced9dfb2a8e37cd8a6c57d21385c249f0b5c2412341287f", + "0x2c5214dfc4d70d2619fce2a7e02ddcf380576dca42b66c9215c7d8d1ec154116", + "0x13abc9bba431e6930c169f5daeb60aedbb27d7618c7ff88b3b4ec1c6de1d6bb8", + "0x0d04c63f36bd168215c9b09a227c7e8d3ad48e2f11b8202fd07c524bd30ee88f", + "0x042c72d0ca208f0631ed947050258333518c26059f0a2ef041e933b1b2a6d8ad", + "0x00c21235cdc5d4241fab782680421cdd99c088a3b48a740d8289d0e67b2ee5da", + "0x1077e8e59029b12e321c47a8a2a25283e50664b6ca1dd766a83828ddc6a22bb9", + "0x15b7bb46f75a6826da53df52c290eda3ddea8924becad6e9a3c08e4eb9a6f604", + "0x0f092097aaee3e41e55706add0701d0eff7a0c972a909dcbc915a478cbc8f122", + "0x2cf33c7d57e1ff8f3d98aabae3092befa8e92274da5e6d324ba0b8839889d27c", + "0x137e350aaf8bab893d768cb6e14bc5464877833efbb8c7091da9ecc7a96bc7b7", + "0x016505cc51b09b257b8c96b5fb20e90bd9e68416286a904d9f86b805e5a89e13", + "0x04d6e1009a70843f5bad89c59765d09421aad04e3276fc90f2a459565057978a", + "0x093a8215cd7e725a45949f4d6d4faec9d078221f09d26a27d61e4f0bf670a580", + "0x1704545cd66b0aa172d2c355fac161d17d7ea42f0132d24708762b544fa17357", + "0x2db6ed73abe6fc42bde50d4422c3e0c81def268d702b9256b7e67cafbbd0325c", + "0x21868e4f8cdcbcb9754d297edc2a361754517465c469017e784a4347f9eb6644", + "0x1adbb821ee5346b1979da8ddbb58789f5ef90c31ece8f0c543c221a3ef0f0aed", + "0x2058aa06a8e23bc53a625831ce1df1aa8d8f01924ad840607f33805aee179d90", + "0x1002be9f0852a234617c837e49555e328bb19a71fcea0ff34368901cee52c85e", + "0x2b238a0d25b834a061e45d817289ab221d13fd0e4cc7adf72d91d54c280f1aa0", + "0x15fada375c113bd526097e297b422ffb59f54a5451e5b70d4a4b028dc65208d1", + "0x2aad701e57c7069cb4e148d971c0eae9ac7429d7d833c51d87875ead0c5aca3c" +] +new_out_hash_sibling_path = [ "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x00f5a5fd42d16a20302798ef6ed309979b43003d2320d9f0e8ea9831a92759fb", + "0x0007638bb56b6dda2b64b8f76841114ac3a87a1820030e2e16772c4d294879c3", + "0x00efcbdb79553ae6863646bf36441755bc344a9a4af335fadc6659594faa4316", + "0x00089a9d421a82c4a25f7acbebe69e638d5b064fa8a60e018793dcb0be53752c" +] +blobs_fields = [ + "0x00000000009c70751800400040000800010040040000000000000000000004cd", + "0x1a462c05a8b08f5c70c3063ad33091f56c6849867cf9c3c3e82d58337f90fd90", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x00000000000000000000000000000000000000000000000000000000b7d1b100", + "0x00000000000000000000000000000000000000000000000000000000b7d1b101", + "0x00000000000000000000000000000000000000000000000000000000b7d1b102", + "0x00000000000000000000000000000000000000000000000000000000b7d1b103", + "0x00000000000000000000000000000000000000000000000000000000b7d1b104", + "0x00000000000000000000000000000000000000000000000000000000b7d1b105", + "0x00000000000000000000000000000000000000000000000000000000b7d1b106", + "0x00000000000000000000000000000000000000000000000000000000b7d1b107", + "0x00000000000000000000000000000000000000000000000000000000b7d1b108", + "0x00000000000000000000000000000000000000000000000000000000b7d1b109", + "0x00000000000000000000000000000000000000000000000000000000b7d1b10a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b10b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b10c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b10d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b10e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b10f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b110", + "0x00000000000000000000000000000000000000000000000000000000b7d1b111", + "0x00000000000000000000000000000000000000000000000000000000b7d1b112", + "0x00000000000000000000000000000000000000000000000000000000b7d1b113", + "0x00000000000000000000000000000000000000000000000000000000b7d1b114", + "0x00000000000000000000000000000000000000000000000000000000b7d1b115", + "0x00000000000000000000000000000000000000000000000000000000b7d1b116", + "0x00000000000000000000000000000000000000000000000000000000b7d1b117", + "0x00000000000000000000000000000000000000000000000000000000b7d1b118", + "0x00000000000000000000000000000000000000000000000000000000b7d1b119", + "0x00000000000000000000000000000000000000000000000000000000b7d1b11a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b11b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b11c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b11d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b11e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b11f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b120", + "0x00000000000000000000000000000000000000000000000000000000b7d1b121", + "0x00000000000000000000000000000000000000000000000000000000b7d1b122", + "0x00000000000000000000000000000000000000000000000000000000b7d1b123", + "0x00000000000000000000000000000000000000000000000000000000b7d1b124", + "0x00000000000000000000000000000000000000000000000000000000b7d1b125", + "0x00000000000000000000000000000000000000000000000000000000b7d1b126", + "0x00000000000000000000000000000000000000000000000000000000b7d1b127", + "0x00000000000000000000000000000000000000000000000000000000b7d1b128", + "0x00000000000000000000000000000000000000000000000000000000b7d1b129", + "0x00000000000000000000000000000000000000000000000000000000b7d1b12a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b12b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b12c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b12d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b12e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b12f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b130", + "0x00000000000000000000000000000000000000000000000000000000b7d1b131", + "0x00000000000000000000000000000000000000000000000000000000b7d1b132", + "0x00000000000000000000000000000000000000000000000000000000b7d1b133", + "0x00000000000000000000000000000000000000000000000000000000b7d1b134", + "0x00000000000000000000000000000000000000000000000000000000b7d1b135", + "0x00000000000000000000000000000000000000000000000000000000b7d1b136", + "0x00000000000000000000000000000000000000000000000000000000b7d1b137", + "0x00000000000000000000000000000000000000000000000000000000b7d1b138", + "0x00000000000000000000000000000000000000000000000000000000b7d1b139", + "0x00000000000000000000000000000000000000000000000000000000b7d1b13a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b13b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b13c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b13d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b13e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b13f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b200", + "0x00000000000000000000000000000000000000000000000000000000b7d1b201", + "0x00000000000000000000000000000000000000000000000000000000b7d1b202", + "0x00000000000000000000000000000000000000000000000000000000b7d1b203", + "0x00000000000000000000000000000000000000000000000000000000b7d1b204", + "0x00000000000000000000000000000000000000000000000000000000b7d1b205", + "0x00000000000000000000000000000000000000000000000000000000b7d1b206", + "0x00000000000000000000000000000000000000000000000000000000b7d1b207", + "0x00000000000000000000000000000000000000000000000000000000b7d1b208", + "0x00000000000000000000000000000000000000000000000000000000b7d1b209", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b210", + "0x00000000000000000000000000000000000000000000000000000000b7d1b211", + "0x00000000000000000000000000000000000000000000000000000000b7d1b212", + "0x00000000000000000000000000000000000000000000000000000000b7d1b213", + "0x00000000000000000000000000000000000000000000000000000000b7d1b214", + "0x00000000000000000000000000000000000000000000000000000000b7d1b215", + "0x00000000000000000000000000000000000000000000000000000000b7d1b216", + "0x00000000000000000000000000000000000000000000000000000000b7d1b217", + "0x00000000000000000000000000000000000000000000000000000000b7d1b218", + "0x00000000000000000000000000000000000000000000000000000000b7d1b219", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b220", + "0x00000000000000000000000000000000000000000000000000000000b7d1b221", + "0x00000000000000000000000000000000000000000000000000000000b7d1b222", + "0x00000000000000000000000000000000000000000000000000000000b7d1b223", + "0x00000000000000000000000000000000000000000000000000000000b7d1b224", + "0x00000000000000000000000000000000000000000000000000000000b7d1b225", + "0x00000000000000000000000000000000000000000000000000000000b7d1b226", + "0x00000000000000000000000000000000000000000000000000000000b7d1b227", + "0x00000000000000000000000000000000000000000000000000000000b7d1b228", + "0x00000000000000000000000000000000000000000000000000000000b7d1b229", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b230", + "0x00000000000000000000000000000000000000000000000000000000b7d1b231", + "0x00000000000000000000000000000000000000000000000000000000b7d1b232", + "0x00000000000000000000000000000000000000000000000000000000b7d1b233", + "0x00000000000000000000000000000000000000000000000000000000b7d1b234", + "0x00000000000000000000000000000000000000000000000000000000b7d1b235", + "0x00000000000000000000000000000000000000000000000000000000b7d1b236", + "0x00000000000000000000000000000000000000000000000000000000b7d1b237", + "0x00000000000000000000000000000000000000000000000000000000b7d1b238", + "0x00000000000000000000000000000000000000000000000000000000b7d1b239", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23f", + "0x0014e392e48abf86fbcc646ebd535dcfadddf685f17cea1ad8692d84091fee6c", + "0x0081d7915f280fb0ab3bc1424d1f3b0afe8b13ca662631eb35d42d344b463ca5", + "0x00108dedfcd6e6ec14921619d606d4e274eb020bb1cceaecaabc10591905ccca", + "0x002d49d5a469f7a62cab3d2b266ed8f6bb38dacb2fb848e61cdbd6f174fa4473", + "0x00c9d057674688ddc5b9dce4037f7a173d54d42423831b1f17c7ad345ba12acb", + "0x00d65baedb6181e9f1d19c3e64ae63b26c0df768927d9654153a4312c0bfb8f9", + "0x00baf276002157aa3a0111d9547fd25bfbefd9d1841ffb292d2801e5354e7d05", + "0x002e2d381dbc44262bbafdf7e1645e1642daf94aa6175667bd69b3452c748e41", + "0x27d08044a627c19f19b7b033af1c9b13f99160a207c22534c11ce11f88ad6814", + "0x0000000000000000000000000000000000000000000000056bc75e2d63100000", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b400", + "0x00000000000000000000000000000000000000000000000000000000b7d1b401", + "0x00000000000000000000000000000000000000000000000000000000b7d1b402", + "0x00000000000000000000000000000000000000000000000000000000b7d1b403", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b401", + "0x00000000000000000000000000000000000000000000000000000000b7d1b402", + "0x00000000000000000000000000000000000000000000000000000000b7d1b403", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b402", + "0x00000000000000000000000000000000000000000000000000000000b7d1b403", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b403", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44b", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44c", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44d", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44e", + "0x00000000009c707518004000400008004000400400000000000000000000054b", + "0x29fc1f0e1f52e308ad45f4965a98d29c1ab694295234af02c93d1cb9c5def714", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x00000000000000000000000000000000000000000000000000000000b7e5c000", + "0x00000000000000000000000000000000000000000000000000000000b7e5c001", + "0x00000000000000000000000000000000000000000000000000000000b7e5c002", + "0x00000000000000000000000000000000000000000000000000000000b7e5c003", + "0x00000000000000000000000000000000000000000000000000000000b7e5c004", + "0x00000000000000000000000000000000000000000000000000000000b7e5c005", + "0x00000000000000000000000000000000000000000000000000000000b7e5c006", + "0x00000000000000000000000000000000000000000000000000000000b7e5c007", + "0x00000000000000000000000000000000000000000000000000000000b7e5c008", + "0x00000000000000000000000000000000000000000000000000000000b7e5c009", + "0x00000000000000000000000000000000000000000000000000000000b7e5c00a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c00b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c00c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c00d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c00e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c00f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c011", + "0x00000000000000000000000000000000000000000000000000000000b7e5c012", + "0x00000000000000000000000000000000000000000000000000000000b7e5c013", + "0x00000000000000000000000000000000000000000000000000000000b7e5c014", + "0x00000000000000000000000000000000000000000000000000000000b7e5c015", + "0x00000000000000000000000000000000000000000000000000000000b7e5c016", + "0x00000000000000000000000000000000000000000000000000000000b7e5c017", + "0x00000000000000000000000000000000000000000000000000000000b7e5c018", + "0x00000000000000000000000000000000000000000000000000000000b7e5c019", + "0x00000000000000000000000000000000000000000000000000000000b7e5c01a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c01b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c01c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c01d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c01e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c01f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c020", + "0x00000000000000000000000000000000000000000000000000000000b7e5c021", + "0x00000000000000000000000000000000000000000000000000000000b7e5c022", + "0x00000000000000000000000000000000000000000000000000000000b7e5c023", + "0x00000000000000000000000000000000000000000000000000000000b7e5c024", + "0x00000000000000000000000000000000000000000000000000000000b7e5c025", + "0x00000000000000000000000000000000000000000000000000000000b7e5c026", + "0x00000000000000000000000000000000000000000000000000000000b7e5c027", + "0x00000000000000000000000000000000000000000000000000000000b7e5c028", + "0x00000000000000000000000000000000000000000000000000000000b7e5c029", + "0x00000000000000000000000000000000000000000000000000000000b7e5c02a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c02b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c02c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c02d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c02e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c02f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c030", + "0x00000000000000000000000000000000000000000000000000000000b7e5c031", + "0x00000000000000000000000000000000000000000000000000000000b7e5c032", + "0x00000000000000000000000000000000000000000000000000000000b7e5c033", + "0x00000000000000000000000000000000000000000000000000000000b7e5c034", + "0x00000000000000000000000000000000000000000000000000000000b7e5c035", + "0x00000000000000000000000000000000000000000000000000000000b7e5c036", + "0x00000000000000000000000000000000000000000000000000000000b7e5c037", + "0x00000000000000000000000000000000000000000000000000000000b7e5c038", + "0x00000000000000000000000000000000000000000000000000000000b7e5c039", + "0x00000000000000000000000000000000000000000000000000000000b7e5c03a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c03b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c03c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c03d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c03e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c03f", + "0x00000000000000000000000000000000000000000000000000000000b7e5b001", + "0x00000000000000000000000000000000000000000000000000000000b7e5c100", + "0x00000000000000000000000000000000000000000000000000000000b7e5c101", + "0x00000000000000000000000000000000000000000000000000000000b7e5c102", + "0x00000000000000000000000000000000000000000000000000000000b7e5c103", + "0x00000000000000000000000000000000000000000000000000000000b7e5c104", + "0x00000000000000000000000000000000000000000000000000000000b7e5c105", + "0x00000000000000000000000000000000000000000000000000000000b7e5c106", + "0x00000000000000000000000000000000000000000000000000000000b7e5c107", + "0x00000000000000000000000000000000000000000000000000000000b7e5c108", + "0x00000000000000000000000000000000000000000000000000000000b7e5c109", + "0x00000000000000000000000000000000000000000000000000000000b7e5c10a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c10b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c10c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c10d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c10e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c10f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c110", + "0x00000000000000000000000000000000000000000000000000000000b7e5c111", + "0x00000000000000000000000000000000000000000000000000000000b7e5c112", + "0x00000000000000000000000000000000000000000000000000000000b7e5c113", + "0x00000000000000000000000000000000000000000000000000000000b7e5c114", + "0x00000000000000000000000000000000000000000000000000000000b7e5c115", + "0x00000000000000000000000000000000000000000000000000000000b7e5c116", + "0x00000000000000000000000000000000000000000000000000000000b7e5c117", + "0x00000000000000000000000000000000000000000000000000000000b7e5c118", + "0x00000000000000000000000000000000000000000000000000000000b7e5c119", + "0x00000000000000000000000000000000000000000000000000000000b7e5c11a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c11b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c11c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c11d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c11e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c11f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c120", + "0x00000000000000000000000000000000000000000000000000000000b7e5c121", + "0x00000000000000000000000000000000000000000000000000000000b7e5c122", + "0x00000000000000000000000000000000000000000000000000000000b7e5c123", + "0x00000000000000000000000000000000000000000000000000000000b7e5c124", + "0x00000000000000000000000000000000000000000000000000000000b7e5c125", + "0x00000000000000000000000000000000000000000000000000000000b7e5c126", + "0x00000000000000000000000000000000000000000000000000000000b7e5c127", + "0x00000000000000000000000000000000000000000000000000000000b7e5c128", + "0x00000000000000000000000000000000000000000000000000000000b7e5c129", + "0x00000000000000000000000000000000000000000000000000000000b7e5c12a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c12b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c12c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c12d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c12e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c12f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c130", + "0x00000000000000000000000000000000000000000000000000000000b7e5c131", + "0x00000000000000000000000000000000000000000000000000000000b7e5c132", + "0x00000000000000000000000000000000000000000000000000000000b7e5c133", + "0x00000000000000000000000000000000000000000000000000000000b7e5c134", + "0x00000000000000000000000000000000000000000000000000000000b7e5c135", + "0x00000000000000000000000000000000000000000000000000000000b7e5c136", + "0x00000000000000000000000000000000000000000000000000000000b7e5c137", + "0x00000000000000000000000000000000000000000000000000000000b7e5c138", + "0x00000000000000000000000000000000000000000000000000000000b7e5c139", + "0x00000000000000000000000000000000000000000000000000000000b7e5c13a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c13b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c13c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c13d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c13e", + "0x00b127f3f010102ee75542c6d7ea6d5882e7684c5ee9356f5ad220c93d67d444", + "0x00dfda5cece61f6680ba771aab12cb53462fef041f2b4b66aa6c65ff0893de6a", + "0x00ce587edb8f2da34e9b79a46b0fd072e0e98a8ef4e0df3f6bf401962acbcf12", + "0x00089a1b3144bd5867811140210d4522e80d2d01aceef8773ca1438313caf3f8", + "0x00a3e975c4eb26d4144db7c1aeba0961560eb0c302c97f7c1658b14a7e153c6a", + "0x003bafff5667638196d10618edf8f2b14a4be1468f4bcf36fef5803c32fba293", + "0x00c9ad352ff74227247dfa18731985cbe86ca423cda60a3d7c5233d2f1b1e584", + "0x00e073f9722b050752a0c38bf2132ac5c9ab55682757cf267c1fe5f534579e2b", + "0x27d08044a627c19f19b7b033af1c9b13f99160a207c22534c11ce11f88ad6814", + "0x0000000000000000000000000000000000000000000000056bc75e2d63100000", + "0x00000000000000000000000000000000000000000000000000000000b7e5d001", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00b", + "0x00000000000000000000000000000000000000000000000000000000b7e5d002", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00c", + "0x00000000000000000000000000000000000000000000000000000000b7e5d003", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00d", + "0x00000000000000000000000000000000000000000000000000000000b7e5d004", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00e", + "0x00000000000000000000000000000000000000000000000000000000b7e5d005", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00f", + "0x00000000000000000000000000000000000000000000000000000000b7e5d006", + "0x00000000000000000000000000000000000000000000000000000000b7e5d010", + "0x00000000000000000000000000000000000000000000000000000000b7e5d007", + "0x00000000000000000000000000000000000000000000000000000000b7e5d011", + "0x00000000000000000000000000000000000000000000000000000000b7e5d008", + "0x00000000000000000000000000000000000000000000000000000000b7e5d012", + "0x00000000000000000000000000000000000000000000000000000000b7e5d009", + "0x00000000000000000000000000000000000000000000000000000000b7e5d013", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00a", + "0x00000000000000000000000000000000000000000000000000000000b7e5d014", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00b", + "0x00000000000000000000000000000000000000000000000000000000b7e5d015", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00c", + "0x00000000000000000000000000000000000000000000000000000000b7e5d016", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00d", + "0x00000000000000000000000000000000000000000000000000000000b7e5d017", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00e", + "0x00000000000000000000000000000000000000000000000000000000b7e5d018", + "0x00000000000000000000000000000000000000000000000000000000b7e5d00f", + "0x00000000000000000000000000000000000000000000000000000000b7e5d019", + "0x00000000000000000000000000000000000000000000000000000000b7e5d010", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01a", + "0x00000000000000000000000000000000000000000000000000000000b7e5d011", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01b", + "0x00000000000000000000000000000000000000000000000000000000b7e5d012", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01c", + "0x00000000000000000000000000000000000000000000000000000000b7e5d013", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01d", + "0x00000000000000000000000000000000000000000000000000000000b7e5d014", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01e", + "0x00000000000000000000000000000000000000000000000000000000b7e5d015", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01f", + "0x00000000000000000000000000000000000000000000000000000000b7e5d016", + "0x00000000000000000000000000000000000000000000000000000000b7e5d020", + "0x00000000000000000000000000000000000000000000000000000000b7e5d017", + "0x00000000000000000000000000000000000000000000000000000000b7e5d021", + "0x00000000000000000000000000000000000000000000000000000000b7e5d018", + "0x00000000000000000000000000000000000000000000000000000000b7e5d022", + "0x00000000000000000000000000000000000000000000000000000000b7e5d019", + "0x00000000000000000000000000000000000000000000000000000000b7e5d023", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01a", + "0x00000000000000000000000000000000000000000000000000000000b7e5d024", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01b", + "0x00000000000000000000000000000000000000000000000000000000b7e5d025", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01c", + "0x00000000000000000000000000000000000000000000000000000000b7e5d026", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01d", + "0x00000000000000000000000000000000000000000000000000000000b7e5d027", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01e", + "0x00000000000000000000000000000000000000000000000000000000b7e5d028", + "0x00000000000000000000000000000000000000000000000000000000b7e5d01f", + "0x00000000000000000000000000000000000000000000000000000000b7e5d029", + "0x00000000000000000000000000000000000000000000000000000000b7e5d020", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02a", + "0x00000000000000000000000000000000000000000000000000000000b7e5d021", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02b", + "0x00000000000000000000000000000000000000000000000000000000b7e5d022", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02c", + "0x00000000000000000000000000000000000000000000000000000000b7e5d023", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02d", + "0x00000000000000000000000000000000000000000000000000000000b7e5d024", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02e", + "0x00000000000000000000000000000000000000000000000000000000b7e5d025", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02f", + "0x00000000000000000000000000000000000000000000000000000000b7e5d026", + "0x00000000000000000000000000000000000000000000000000000000b7e5d030", + "0x00000000000000000000000000000000000000000000000000000000b7e5d027", + "0x00000000000000000000000000000000000000000000000000000000b7e5d031", + "0x00000000000000000000000000000000000000000000000000000000b7e5d028", + "0x00000000000000000000000000000000000000000000000000000000b7e5d032", + "0x00000000000000000000000000000000000000000000000000000000b7e5d029", + "0x00000000000000000000000000000000000000000000000000000000b7e5d033", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02a", + "0x00000000000000000000000000000000000000000000000000000000b7e5d034", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02b", + "0x00000000000000000000000000000000000000000000000000000000b7e5d035", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02c", + "0x00000000000000000000000000000000000000000000000000000000b7e5d036", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02d", + "0x00000000000000000000000000000000000000000000000000000000b7e5d037", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02e", + "0x00000000000000000000000000000000000000000000000000000000b7e5d038", + "0x00000000000000000000000000000000000000000000000000000000b7e5d02f", + "0x00000000000000000000000000000000000000000000000000000000b7e5d039", + "0x00000000000000000000000000000000000000000000000000000000b7e5d030", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03a", + "0x00000000000000000000000000000000000000000000000000000000b7e5d031", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03b", + "0x00000000000000000000000000000000000000000000000000000000b7e5d032", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03c", + "0x00000000000000000000000000000000000000000000000000000000b7e5d033", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03d", + "0x00000000000000000000000000000000000000000000000000000000b7e5d034", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03e", + "0x00000000000000000000000000000000000000000000000000000000b7e5d035", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03f", + "0x00000000000000000000000000000000000000000000000000000000b7e5d036", + "0x00000000000000000000000000000000000000000000000000000000b7e5d040", + "0x00000000000000000000000000000000000000000000000000000000b7e5d037", + "0x00000000000000000000000000000000000000000000000000000000b7e5d041", + "0x00000000000000000000000000000000000000000000000000000000b7e5d038", + "0x00000000000000000000000000000000000000000000000000000000b7e5d042", + "0x00000000000000000000000000000000000000000000000000000000b7e5d039", + "0x00000000000000000000000000000000000000000000000000000000b7e5d043", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03a", + "0x00000000000000000000000000000000000000000000000000000000b7e5d044", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03b", + "0x00000000000000000000000000000000000000000000000000000000b7e5d045", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03c", + "0x00000000000000000000000000000000000000000000000000000000b7e5d046", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03d", + "0x00000000000000000000000000000000000000000000000000000000b7e5d047", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03e", + "0x00000000000000000000000000000000000000000000000000000000b7e5d048", + "0x00000000000000000000000000000000000000000000000000000000b7e5d03f", + "0x00000000000000000000000000000000000000000000000000000000b7e5d049", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c300", + "0x00000000000000000000000000000000000000000000000000000000b7e5c301", + "0x00000000000000000000000000000000000000000000000000000000b7e5c302", + "0x00000000000000000000000000000000000000000000000000000000b7e5c303", + "0x00000000000000000000000000000000000000000000000000000000b7e5c304", + "0x00000000000000000000000000000000000000000000000000000000b7e5c305", + "0x00000000000000000000000000000000000000000000000000000000b7e5c306", + "0x00000000000000000000000000000000000000000000000000000000b7e5c307", + "0x00000000000000000000000000000000000000000000000000000000b7e5c308", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c301", + "0x00000000000000000000000000000000000000000000000000000000b7e5c302", + "0x00000000000000000000000000000000000000000000000000000000b7e5c303", + "0x00000000000000000000000000000000000000000000000000000000b7e5c304", + "0x00000000000000000000000000000000000000000000000000000000b7e5c305", + "0x00000000000000000000000000000000000000000000000000000000b7e5c306", + "0x00000000000000000000000000000000000000000000000000000000b7e5c307", + "0x00000000000000000000000000000000000000000000000000000000b7e5c308", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c302", + "0x00000000000000000000000000000000000000000000000000000000b7e5c303", + "0x00000000000000000000000000000000000000000000000000000000b7e5c304", + "0x00000000000000000000000000000000000000000000000000000000b7e5c305", + "0x00000000000000000000000000000000000000000000000000000000b7e5c306", + "0x00000000000000000000000000000000000000000000000000000000b7e5c307", + "0x00000000000000000000000000000000000000000000000000000000b7e5c308", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c303", + "0x00000000000000000000000000000000000000000000000000000000b7e5c304", + "0x00000000000000000000000000000000000000000000000000000000b7e5c305", + "0x00000000000000000000000000000000000000000000000000000000b7e5c306", + "0x00000000000000000000000000000000000000000000000000000000b7e5c307", + "0x00000000000000000000000000000000000000000000000000000000b7e5c308", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c304", + "0x00000000000000000000000000000000000000000000000000000000b7e5c305", + "0x00000000000000000000000000000000000000000000000000000000b7e5c306", + "0x00000000000000000000000000000000000000000000000000000000b7e5c307", + "0x00000000000000000000000000000000000000000000000000000000b7e5c308", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c305", + "0x00000000000000000000000000000000000000000000000000000000b7e5c306", + "0x00000000000000000000000000000000000000000000000000000000b7e5c307", + "0x00000000000000000000000000000000000000000000000000000000b7e5c308", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c306", + "0x00000000000000000000000000000000000000000000000000000000b7e5c307", + "0x00000000000000000000000000000000000000000000000000000000b7e5c308", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c307", + "0x00000000000000000000000000000000000000000000000000000000b7e5c308", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c308", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c309", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c30f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c310", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c311", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c312", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c313", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c314", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c315", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c316", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c317", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c318", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c319", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c31f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c320", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c321", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c322", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c323", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c324", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c325", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c326", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c327", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c328", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c329", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c32f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c330", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c331", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c332", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c333", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c334", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c335", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c336", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c337", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x00000000000000000000000000000000000000000000000000000000b7e5c346", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c338", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x00000000000000000000000000000000000000000000000000000000b7e5c346", + "0x00000000000000000000000000000000000000000000000000000000b7e5c347", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c339", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x00000000000000000000000000000000000000000000000000000000b7e5c346", + "0x00000000000000000000000000000000000000000000000000000000b7e5c347", + "0x00000000000000000000000000000000000000000000000000000000b7e5c348", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x00000000000000000000000000000000000000000000000000000000b7e5c346", + "0x00000000000000000000000000000000000000000000000000000000b7e5c347", + "0x00000000000000000000000000000000000000000000000000000000b7e5c348", + "0x00000000000000000000000000000000000000000000000000000000b7e5c349", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x00000000000000000000000000000000000000000000000000000000b7e5c346", + "0x00000000000000000000000000000000000000000000000000000000b7e5c347", + "0x00000000000000000000000000000000000000000000000000000000b7e5c348", + "0x00000000000000000000000000000000000000000000000000000000b7e5c349", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34a", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x00000000000000000000000000000000000000000000000000000000b7e5c346", + "0x00000000000000000000000000000000000000000000000000000000b7e5c347", + "0x00000000000000000000000000000000000000000000000000000000b7e5c348", + "0x00000000000000000000000000000000000000000000000000000000b7e5c349", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34b", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x00000000000000000000000000000000000000000000000000000000b7e5c346", + "0x00000000000000000000000000000000000000000000000000000000b7e5c347", + "0x00000000000000000000000000000000000000000000000000000000b7e5c348", + "0x00000000000000000000000000000000000000000000000000000000b7e5c349", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34c", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33e", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x00000000000000000000000000000000000000000000000000000000b7e5c346", + "0x00000000000000000000000000000000000000000000000000000000b7e5c347", + "0x00000000000000000000000000000000000000000000000000000000b7e5c348", + "0x00000000000000000000000000000000000000000000000000000000b7e5c349", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34d", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x00000000000000000000000000000000000000000000000000000000b7e5c33f", + "0x00000000000000000000000000000000000000000000000000000000b7e5c340", + "0x00000000000000000000000000000000000000000000000000000000b7e5c341", + "0x00000000000000000000000000000000000000000000000000000000b7e5c342", + "0x00000000000000000000000000000000000000000000000000000000b7e5c343", + "0x00000000000000000000000000000000000000000000000000000000b7e5c344", + "0x00000000000000000000000000000000000000000000000000000000b7e5c345", + "0x00000000000000000000000000000000000000000000000000000000b7e5c346", + "0x00000000000000000000000000000000000000000000000000000000b7e5c347", + "0x00000000000000000000000000000000000000000000000000000000b7e5c348", + "0x00000000000000000000000000000000000000000000000000000000b7e5c349", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34a", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34b", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34c", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34d", + "0x00000000000000000000000000000000000000000000000000000000b7e5c34e", + "0x0000000000000000000000000000eb8dcdbf0000000000000186000000010002", + "0x00000000000000000040000000000200000000010000000000bf00000006b6c0", + "0x0fb2945d3438d906d88a216364dbfe9760e96001343468610e01d18182d493d0", + "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b", + "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00", + "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759", + "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b", + "0x0000000000000000000000000000000000000000000000008c63744300000a20", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -25334,49 +25960,49 @@ blobs_fields = [ "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000" ] -blobs_hash = "0x00f09841b6beb6ac35e2d402e872f1408b67f5c5c84e46dc3787b46156d7f84c" +blobs_hash = "0x00db8109241a08a13a0d293ca0e8207199fdd6df64e0530c6e272802c3a33710" [inputs.hints.previous_block_header] - sponge_blob_hash = "0x0b313f5b633f0a3900167237b8b327f56fd8a1b294008e6527004c920d1e0c06" - total_fees = "0x000000000000000000000000000000000000000000000000001e63b1d6a4b780" - total_mana_used = "0x00000000000000000000000000000000000000000000000000000000000a3982" + sponge_blob_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" + total_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" + total_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.hints.previous_block_header.last_archive] - root = "0x16d512452fc6d3fe373224d568f89a90072bc29881297e1053501494ea43bb0c" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000008" + root = "0x0000000000000000000000000000000000000000000000000000000000000000" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.hints.previous_block_header.state.l1_to_l2_message_tree] root = "0x0fef6d80d31109ddb56d6b3f607cbc9c0af0bff3ea0d43e8f278983c64c11f7a" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000001800" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.hints.previous_block_header.state.partial.note_hash_tree] -root = "0x034b30004686b0cbe57927eaa548af4a428eabee71f4e3e8a581a43084facde5" -next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000140" +root = "0x2590f2aab19dd791700b4a43d3f52bb88ef2409a3731da8e848663559202e4c6" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.hints.previous_block_header.state.partial.nullifier_tree] -root = "0x1c13b69ab508e560dc7c25e4f77aed48439749310a58609f31475734efe7287b" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000001c0" +root = "0x18935581a8ed73d08ffd00386fba55ba6c89f3ab848a76b8fedfa9034cee0454" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.hints.previous_block_header.state.partial.public_data_tree] -root = "0x073b8408b98dbac4d5f0c84d47161ee954b8d8e7920e620bf14bc44cb50d07d5" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000008b" +root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" +next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.hints.previous_block_header.global_variables] - chain_id = "0x0000000000000000000000000000000000000000000000000000000000007a69" - version = "0x000000000000000000000000000000000000000000000000000000005fe47cc3" - block_number = "0x0000000000000000000000000000000000000000000000000000000000000008" - slot_number = "0x0000000000000000000000000000000000000000000000000000000000000025" - timestamp = "0x000000000000000000000000000000000000000000000000000000006a4d2189" + chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + version = "0x0000000000000000000000000000000000000000000000000000000000000000" + block_number = "0x0000000000000000000000000000000000000000000000000000000000000000" + slot_number = "0x0000000000000000000000000000000000000000000000000000000000000000" + timestamp = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.hints.previous_block_header.global_variables.coinbase] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.hints.previous_block_header.global_variables.fee_recipient] inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.hints.previous_block_header.global_variables.gas_fees] fee_per_da_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" - fee_per_l2_gas = "0x00000000000000000000000000000000000000000000000000000002f8e08bc0" + fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.hints.previous_out_hash] root = "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093" @@ -25421,13 +26047,13 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 ] [inputs.hints.final_blob_challenges] - z = "0x1fdc12adc29013642cd3e65ed4fe6257a51f0de3dbf9aab308d2eb764d2e2a6c" + z = "0x2e80beacb53a9662ec507db7bc19d1f8758840646d814571fdb617f696b20708" [inputs.hints.final_blob_challenges.gamma] limbs = [ - "0x3091f45075ebc6c0e8bd0d0b55148a", - "0xba36f4511ca8e170b8a14a64a7418f", - "0x070d" + "0xc535576609c4d6fcbf3ef94644b75e", + "0x42c4943e4bacf827454f282cab9652", + "0x132e" ] [[inputs.hints.blob_commitments]] @@ -25435,18 +26061,18 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 [inputs.hints.blob_commitments.x] limbs = [ - "0xdc0744575b26b4c4b7ee41dc7bee5a", - "0xab24ae0f1c266615b22dc3e9ffeecf", - "0xb738f18d636a06615561d266fd2d4d", - "0x19668e" + "0x4dba477e3f05aa581d83376f6f1a61", + "0xec80c39f7dcc68824280aa23b93ebc", + "0xec06d27c70fbab1135a72fc1f776a7", + "0x0b3e0d" ] [inputs.hints.blob_commitments.y] limbs = [ - "0x713d223616e8efe8cd4821efdde4f2", - "0x9a9a221be261841a9296b4d1eefd77", - "0xdb1af24cb0ccdcba1a7900c4fc1ad5", - "0x15b665" + "0x4e8000f58faaadee26545f5da82d9f", + "0x8f4970c5f75c2f731f90e29e5a4f16", + "0x01541d2e75e3837911bf397eccba63", + "0x075771" ] [[inputs.hints.blob_commitments]] diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-root/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-root/Prover.toml index 365629ea0dba..a52fbdb30b24 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-root/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-checkpoint-root/Prover.toml @@ -484,17 +484,17 @@ proof = [ [inputs.previous_rollups.public_inputs] timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186" - block_headers_hash = "0x17c4bb819a9cc0d99d5e3adbe3afc8004e565750767388207337e77c8a097f53" - in_hash = "0x00b0e02949c7c042e780651385688dcec114af3dbb3892bab1a9cd8e2bbafdc5" - out_hash = "0x00bd3da907cbb210cd100bd369f8dd7eb04b938c69dce277dc1efea8403ed88e" + block_headers_hash = "0x2a848bd23c9096b0e392d4a218ae4026355790bb2acea3cc385f56d21cb2b90b" + is_first_block = true + out_hash = "0x00746f2611b7b24448263e846ba73bf1861fc6e68dbc605414405a520957a902" accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" - accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000" + accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0" [inputs.previous_rollups.public_inputs.constants] chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" version = "0x0000000000000000000000000000000000000000000000000000000000000000" - vk_tree_root = "0x11065543c9a42eac842466277ee9149b27403e398e94c6bba4f525931a2ac6bc" - protocol_contracts_hash = "0x24b2bd6e0456d2d2e64beb505010896a57017c6dedf7516d314d551720c3e6b4" + vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f" @@ -513,7 +513,7 @@ proof = [ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [inputs.previous_rollups.public_inputs.new_archive] - root = "0x02c1e55021910a8552fe034bd1dad5769dec59fc837d88b03d9cf7a8bba0a348" + root = "0x117aeecc54e82e86461b9fdcf0a0b047ec63a08ecbf4701f5e0898efafa79b29" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000003" [inputs.previous_rollups.public_inputs.start_state.l1_to_l2_message_tree] @@ -533,20 +533,20 @@ root = "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.end_state.l1_to_l2_message_tree] -root = "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" +root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.end_state.partial.note_hash_tree] -root = "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449" +root = "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.end_state.partial.nullifier_tree] -root = "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8" +root = "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" [inputs.previous_rollups.public_inputs.end_state.partial.public_data_tree] -root = "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000fe" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollups.public_inputs.start_sponge_blob] num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -567,154 +567,190 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 squeeze_mode = false [inputs.previous_rollups.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000aa3" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a25" [inputs.previous_rollups.public_inputs.end_sponge_blob.sponge] cache = [ - "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8", - "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f", - "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449" + "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00", + "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759", + "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" ] state = [ - "0x15da51316f6d05717039ebdac951746a67f2039305acba3dde6937f37537a3be", - "0x18d3719d0b48c48b53ca67a10f27a44337f426a5765bad3dacedaacfb6ccac97", - "0x14aff5482ea838000d13644e493656299d3e8d89a40030dbe5ca9bfc7ca80e9b", - "0x101f0785768c74cde83892e08bc25e14d7aff6304b2281bbcdee77377417c602" + "0x135c92350c7353b08f2cb63fded7ce4c854c495584ef333288940d669ce6a599", + "0x21b216cea5b04aad8cdf1f5d9722403e9c7bc282a3a779e4ffe3f1de6c993da9", + "0x21ab5208b30e3512fa415157976f94403dbbfad370f532e03abcbfb2d8b0ac61", + "0x19b5e475d9036a98cc36422f737a08e3eb651f24b19706f6a11087216ddf4a0b" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" squeeze_mode = false + [inputs.previous_rollups.public_inputs.start_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.previous_rollups.public_inputs.start_msg_sponge.sponge] + cache = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + state = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000000" + squeeze_mode = false + + [inputs.previous_rollups.public_inputs.end_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.previous_rollups.public_inputs.end_msg_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" +] + state = [ + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false + [inputs.previous_rollups.vk_data] leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000f" sibling_path = [ - "0x01343c2fd6c1ffb7f74e657666d03b4842aa647357eeafa82c9a740c7ab7c0f5", - "0x279cfadc25df7db3e8d0a15e10ff6e5f4bcb741888255ef55ded2c7e7f364ffe", - "0x1944964394682423d7fc879430c65da6feda679bf7aba3c1e99a6cbd464ada9a", - "0x0481dbd69f3e084904030eb9771134ae7be848ec7b4af69e75933270ceeb544d", - "0x1fe698f1a6368c855525a9abcc3713bb49b1dec627f796bf4e23cc86473621ec", - "0x1c7b07f7b3f8344fece2e6a10bc9480dc4b90f89d2a51f344bee80ca5a4bda6e", - "0x12ed8e93726f8b5b79d1291566a72c1775861d60bba2daa19edb3f28d0ae7a3e" + "0x155cff86f825326297a0cab7be11b73de2f60861977b08a76395b27b53212633", + "0x2d7f66d8c425cb437f6ffa40846cb4973f850fb874bf2590bb58aa28730171bd", + "0x1b222531f0055fae25fdfaf1f505d1659b8279dcd4d0f333ca8905cc8aa9661d", + "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd", + "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d", + "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", + "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd" ] [inputs.previous_rollups.vk_data.vk] key = [ "0x0000000000000000000000000000000000000000000000000000000000000015", - "0x0000000000000000000000000000000000000000000000000000000000000046", + "0x000000000000000000000000000000000000000000000000000000000000005a", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x0000000000000000000000000000006a9667dccdd162d2ae42f4e052ab6feb00", - "0x0000000000000000000000000000000000063291bd0b843c87aff87dbeb8776f", - "0x0000000000000000000000000000004a3e0e4fadc23eda87a6e0b7e2770f97d0", - "0x000000000000000000000000000000000004231112238efcd5a8bbfdf02126af", - "0x00000000000000000000000000000057d27c9209ecd83d9d45357a73671b03ff", - "0x00000000000000000000000000000000000530da1a5fe1fa70f89a7b25183101", - "0x000000000000000000000000000000138ac4080e122ce141128960ac2c5cfd20", - "0x0000000000000000000000000000000000090980ae28917dd4a854759ba202ed", - "0x000000000000000000000000000000fd615c5e6be695bc3f08cb6fbc89726d3a", - "0x00000000000000000000000000000000002e4ee78c63f411c0f2731a1de4234f", - "0x000000000000000000000000000000f7ecdc73440e0f108dc4756df4bfedd84e", - "0x00000000000000000000000000000000002e1eda2438deabb21604f9b80842a4", - "0x0000000000000000000000000000001d3aef4dde892039943e1aeb0d978b20b6", - "0x000000000000000000000000000000000026f3aa754f63457a19998cd5a191d8", - "0x000000000000000000000000000000ac00b422a1ba12bc88fc941a3773b9b62b", - "0x00000000000000000000000000000000001777437ecae54c2781ba66be067d35", - "0x00000000000000000000000000000038481039363f02fcfc4ebd2da51e9d3cc9", - "0x0000000000000000000000000000000000182aba9f2da6e353b27eab1da98c66", - "0x0000000000000000000000000000008b49c75f3efe3ce830c093f883b7d81dc3", - "0x0000000000000000000000000000000000173b08f18df8f22f4051139253d804", - "0x000000000000000000000000000000524613a71ac75a0986d68582ceee6d47bd", - "0x00000000000000000000000000000000001f7e863054817fd349c1a60b6a1b4a", - "0x00000000000000000000000000000001752f62b903d26d79dd6a7398688b5631", - "0x000000000000000000000000000000000003021cb3a85e9463776084ae58a1bd", - "0x000000000000000000000000000000f32d72552e36ee057e56dee89bd470cf9c", - "0x00000000000000000000000000000000002446c410b40892fcef669e0da042a5", - "0x0000000000000000000000000000001c35a61d019a29ff6291b33a41206dd94b", - "0x0000000000000000000000000000000000182dc003198330d46ee04d2ce8829c", - "0x000000000000000000000000000000e97e2dd7dbadcc2995c1e0fcab49fd8f29", - "0x0000000000000000000000000000000000082a0d78185ebf44c412ee980086cc", - "0x000000000000000000000000000000f6d9120bd11108d12ebac08ee2a73a4ee2", - "0x000000000000000000000000000000000016c73e09ea4a37f39f4ae7ebadad6b", + "0x000000000000000000000000000000f1e7ddcc14d1a5d954b81215388a0d348d", + "0x00000000000000000000000000000000000a5caa9ffe2cd5d44288655960fbb9", + "0x00000000000000000000000000000039722eedf301c4f0a8efd6f2a5b349af4c", + "0x000000000000000000000000000000000002fc484866ff4729771b06d59730d3", + "0x0000000000000000000000000000000a13bcac0492974dedf395a6af8eea80d3", + "0x00000000000000000000000000000000002addf6796f866bdc0ed3be86404372", + "0x0000000000000000000000000000005eb92f69d61631d10b47a8e07e15ba655f", + "0x00000000000000000000000000000000001443b0b67361085f625a568644b015", + "0x000000000000000000000000000000a74214365af1b6d41319c9dd8382e9a8f0", + "0x00000000000000000000000000000000002f76e511e2c969dbc5eecb7f670071", + "0x0000000000000000000000000000000001504b38af9f0066a9d2bfbfa02b3b08", + "0x00000000000000000000000000000000000d73b83290e156de6a240fd3ae1b2b", + "0x0000000000000000000000000000006abfb3e6bd55642eb7ed0c7197cfa7a3dd", + "0x0000000000000000000000000000000000076f4d5cfa5c8088106a0c7a9cfa90", + "0x0000000000000000000000000000000709f2356dab09214b4171d4f1d3323326", + "0x00000000000000000000000000000000000b14f0f3f64d7e357a45f0276a1ea9", + "0x0000000000000000000000000000003babe5a95fdd4610840a724bd2ed3828e1", + "0x0000000000000000000000000000000000201cdfdb5a5bc4703457f89df55f98", + "0x000000000000000000000000000000b3fac9da70ad5fa3860ec0ce960f8981d9", + "0x000000000000000000000000000000000010b10135960c565c5349d5f789b5b1", + "0x000000000000000000000000000000c305056fc5f0a60230121d87f8a5d5cb8a", + "0x000000000000000000000000000000000029325cbe3d90e4f70ea17d72e0c4fd", + "0x0000000000000000000000000000009083c259c2a18982a69f48b80acd80bcc4", + "0x00000000000000000000000000000000000218a1611680626e6a316d0b789c69", + "0x0000000000000000000000000000001e8f0c3e04a78ba2ed7ab06f3bbc7715f5", + "0x000000000000000000000000000000000027cbd768f12d7c17b58c80509d62f5", + "0x0000000000000000000000000000003923892efe2dc2fa020857749ce62d5439", + "0x000000000000000000000000000000000014395b407fc85c60a3250accf76758", + "0x0000000000000000000000000000006edff51b3196ff338accb863e273712472", + "0x0000000000000000000000000000000000179cd05231571e8a1f63d1c48674d1", + "0x000000000000000000000000000000195985990189ea39cf9537a33353284b57", + "0x000000000000000000000000000000000005b499926e55583ec9d33533a4293e", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x000000000000000000000000000000274ddacf8e96776fe797a1569ab9b79085", - "0x00000000000000000000000000000000002866896852c4af3959a75cacc3a632", - "0x000000000000000000000000000000f88ab574d4ca30564608764a8253c59d75", - "0x000000000000000000000000000000000022427337a713b58d3d8fde1a1235c1", - "0x0000000000000000000000000000004724cde9ce06e5411caabd7dd4fe2dcf89", - "0x0000000000000000000000000000000000267e7e5f0e6e2991964e87475f961b", - "0x0000000000000000000000000000001f11b31d10d889999d1f1349f99703a55f", - "0x00000000000000000000000000000000001ca2da1bd75c23c6533fc450360e0a", - "0x000000000000000000000000000000afbed629fb5fa26fc41e8a923b9ee70fa5", - "0x00000000000000000000000000000000002dbe4a15a76cab43f9be075522c4f7", - "0x000000000000000000000000000000f872acaefe3c6d6ce10c87d61b829fbbec", - "0x00000000000000000000000000000000000da796b562c87f2895396300fea539", - "0x000000000000000000000000000000c9f0341494ab58f3e1e930a49a555b3530", - "0x0000000000000000000000000000000000209512993e91e87bb1d8858c75ece1", - "0x0000000000000000000000000000006909e9ae72e572edc17af4fdf7b4e755eb", - "0x00000000000000000000000000000000001ec0e3b93e01c67030c1aa756fcb40", - "0x0000000000000000000000000000008ce19cfbcd9d36b4d6c2b1c8b00c7ac4ed", - "0x00000000000000000000000000000000002b8384ee941d9da9a54abd43f2277e", - "0x000000000000000000000000000000e0655aece8058e01830ab3c2fccfaf43d4", - "0x00000000000000000000000000000000002129825ddff055bff8da3ac65f9d97", - "0x00000000000000000000000000000072446655f6fbebd858814689ee8d77f733", - "0x00000000000000000000000000000000000fbd2b0c165ae278d54a9f26a77ddb", - "0x00000000000000000000000000000002774107a304abf72ed2ebe7e179274c53", - "0x000000000000000000000000000000000012e445ab5de7b8fd0c6fb507c66a79", - "0x000000000000000000000000000000d14ce80691e789f2d6eef88c0e19739224", - "0x000000000000000000000000000000000015a7d8d72ac0cd46dece1ed45d9cf0", - "0x000000000000000000000000000000dfde16ba0db9360fb86ea22c03a4b0ba15", - "0x00000000000000000000000000000000002557f14c86a34be75255705fe08561", - "0x00000000000000000000000000000019d8b84ecc1a26c797ca5539f68cec2d42", - "0x000000000000000000000000000000000007189c147cd9a5129667b6012c4f5d", - "0x00000000000000000000000000000041054d81036e294b6d2365cc52d68deff4", - "0x00000000000000000000000000000000003047192f88bb7ca1a719faed1a2e0a", - "0x0000000000000000000000000000008f046cbba2c9c3a6a62634c8e14548dd79", - "0x00000000000000000000000000000000000f06ee1ef78193dc70df4c96a85909", - "0x000000000000000000000000000000f3b850e16e232b15077c8ae63bb780225e", - "0x00000000000000000000000000000000000c27b5763ba877829c5ea2028b62e9", - "0x00000000000000000000000000000034a75eaa6b329f2f9ba326bd197b09141e", - "0x0000000000000000000000000000000000202dfa08500a2e8f25017df19adf25", - "0x0000000000000000000000000000008afad1cc67ef6859e2e69f0e109aa60e53", - "0x0000000000000000000000000000000000202651c9cbf4f7bdc4c09481a7183e", - "0x0000000000000000000000000000004ad0e61ee6d136fec3cb6245c23a9d7fa4", - "0x00000000000000000000000000000000001ba6a85f42e9b747bdeb9ec693903d", - "0x000000000000000000000000000000f9167bc703d3994f127e4405ace11cd370", - "0x0000000000000000000000000000000000179429037ebb68f9eaab32e6b0fd95", - "0x00000000000000000000000000000067eef44d6bcc8c84c816c23e48fff9ef1a", - "0x00000000000000000000000000000000000dfaa11abdeec9d4d439ea513fe1bb", - "0x00000000000000000000000000000037299bad92af61aa5b7b7420e2136acd46", - "0x00000000000000000000000000000000001fcbf38a01e3cdf02d1366e71fe833", - "0x0000000000000000000000000000002d8da352b8f27deadac5e960d6e9cb277e", - "0x0000000000000000000000000000000000017bc6f28e4bc9a0ac3ef7569f355b", - "0x0000000000000000000000000000000fcc89a859300fc26d1b6e20c3f1f0aa69", - "0x00000000000000000000000000000000000db738295e84091db3b486a35f79af", - "0x00000000000000000000000000000098974828efb9f8c5313d1990a314808072", - "0x0000000000000000000000000000000000105acf3c77cd5b34b03c6ced8374e8", - "0x000000000000000000000000000000e41f37e5a17c5783f1366590879f3571c3", - "0x00000000000000000000000000000000002567eeabaff2b5808d012d63a8eca4", - "0x000000000000000000000000000000cbefc522c75dca6006c0eec85fb7cf2895", - "0x000000000000000000000000000000000008b1474a3d82ba5e951d3bc1190c54", - "0x000000000000000000000000000000658b1f0d08a6a2f6416bb93ba41bab1f65", - "0x000000000000000000000000000000000010cfb1307729684fd09a393e65859f", - "0x000000000000000000000000000000af595242eb57b0c44971b382c747414407", - "0x00000000000000000000000000000000001533ad4cd0ccb5f880d623c15193ac", - "0x0000000000000000000000000000002e715a02801c283d94e775da9677c3768e", - "0x000000000000000000000000000000000003a5eb9c1337e402b217b9c77fbd90", - "0x000000000000000000000000000000c41740632c841c230a98008525df0a1755", - "0x0000000000000000000000000000000000032858262782b159d5555f8b2e1da7", - "0x0000000000000000000000000000003e61e55d2d51e902fc1c1ca115e973d267", - "0x000000000000000000000000000000000017b56ae8be5f5dc134757ff9487968", - "0x00000000000000000000000000000069aa6cf9ffa5d5ac54c3db14701b8f8145", - "0x0000000000000000000000000000000000125f0b462cd93e4790785c1736a2ae", - "0x000000000000000000000000000000b8f6d5cf38acbf0f3256d9741eafc99913", - "0x00000000000000000000000000000000002cb43f5142fc186556989821e0285f", - "0x000000000000000000000000000000c2958e062d6920c6e2d8b2608c3d5ef552", - "0x0000000000000000000000000000000000064323312ffe1e7332a7400d475bd6", - "0x000000000000000000000000000000a3354f4bc1b37dde35b3cd6a6d8512c79b", - "0x00000000000000000000000000000000001dd4d808f01886425ccca7cb48ca2f" + "0x0000000000000000000000000000002972a9e49d9e5f60a10ee805ff2615663d", + "0x00000000000000000000000000000000002970fe8086600390dee3b98f7d940c", + "0x000000000000000000000000000000bfb1312cbda593e8f4c5473b47d35e3ff2", + "0x00000000000000000000000000000000000766be596296788b2e61417586c808", + "0x00000000000000000000000000000013e4441cf7e4a6a389a39dc21c24275be2", + "0x0000000000000000000000000000000000017aab51c397a2d57778ebe5022782", + "0x00000000000000000000000000000009adaeede4203a41f991031ec50f09bb98", + "0x00000000000000000000000000000000002c9fa3c370cbb1f1bc9128d27307d8", + "0x00000000000000000000000000000086f83dd5fa9178c3c683137ef6a3018c50", + "0x00000000000000000000000000000000000af8d38dc8b77bda3980c013658848", + "0x0000000000000000000000000000007307ee1df3133617f2e5a4d2bbb01f449f", + "0x00000000000000000000000000000000002e27ed3b0658fb9d44ebdb9e459679", + "0x00000000000000000000000000000037ec6f22980fbc5a795d816788a7c7fd87", + "0x000000000000000000000000000000000022973f4a5a82fd556aad37856af147", + "0x000000000000000000000000000000f6f48a91dac1f229b2b35e0fe3ef98abfb", + "0x000000000000000000000000000000000011b923ec095c6746d167d68a4b20e8", + "0x0000000000000000000000000000002d4825c2a902a49bad97fcf3510dea717e", + "0x00000000000000000000000000000000000a00b7e38d47dba44d1fa8d9e462d8", + "0x000000000000000000000000000000f14f2adda7c6729037603c11f6df57543b", + "0x00000000000000000000000000000000000bd236e34f1859cda4709a1895cdab", + "0x000000000000000000000000000000d3678bafd3a8f024c9373604ff3b9445e5", + "0x00000000000000000000000000000000002e41d5db4cb0fc20648504962c7e38", + "0x0000000000000000000000000000004ea6f803bdb1c654c7a3e38c2fc5747710", + "0x000000000000000000000000000000000012b2e307e4788fa75f5058585d1ba3", + "0x00000000000000000000000000000040e8f553b98122828b8a5bb679e7deb97a", + "0x00000000000000000000000000000000000a216b89977ad13bdff479764a27ca", + "0x000000000000000000000000000000933e4f2e04d2cded7e8cd136f18fcc4091", + "0x000000000000000000000000000000000015fcaee6b450c9e8fe7c6f82f7935e", + "0x00000000000000000000000000000000fef9ed223e1c4b1878f1382bb011d550", + "0x00000000000000000000000000000000002375a63f44311595e11cb13f5283f1", + "0x000000000000000000000000000000a7c977ccaf50e4d717c7ae36304af0dc66", + "0x0000000000000000000000000000000000010920abd2eae86f85d82ad9f88492", + "0x000000000000000000000000000000ef0a0674e70bb44ff728d53f5dbfabf7c1", + "0x00000000000000000000000000000000000d68a4ddf4aec05a29640ad1d40ee4", + "0x0000000000000000000000000000007123314f83f27f4833a0048b091d5d62b6", + "0x00000000000000000000000000000000000a8fd7bbc8ee63940f2baf92b53fd5", + "0x000000000000000000000000000000be04b6d97a1a16de66c8bae98cf95e37cc", + "0x000000000000000000000000000000000006849ce9eea56fb180865427034d54", + "0x0000000000000000000000000000002af94cb2b8ffa891913cb9840112bf0418", + "0x000000000000000000000000000000000021996f6ad0f8bb920691927dbcd592", + "0x000000000000000000000000000000fa6286fbf6c493e14b6486f0cb3b76251a", + "0x0000000000000000000000000000000000152c8222ea71be700b89cff2af9bcd", + "0x00000000000000000000000000000067aa0c105df79de2b889a044ecbf3d8d79", + "0x0000000000000000000000000000000000038fb4352d33ac89eeb1cfc441a140", + "0x000000000000000000000000000000b7cc4690c5191469ed4ce6ff94de732ec3", + "0x00000000000000000000000000000000001f533df11d1b8dd79d8af4331d0e65", + "0x000000000000000000000000000000ed3b9d0cc168e1dfdad7343c19a8ca5151", + "0x0000000000000000000000000000000000102355cb5d373d6ad337357a29a49d", + "0x000000000000000000000000000000f72372e068b952b940f0bed9060022b6be", + "0x00000000000000000000000000000000002baec2a144a6d761036c92a80f2b7d", + "0x000000000000000000000000000000cbb74d3007ba42781996344e39eed8ca92", + "0x00000000000000000000000000000000002ead419fd4671a2c55d8e213322757", + "0x0000000000000000000000000000004f1f9b46d63bb7d3f29fef23cdee865eb0", + "0x000000000000000000000000000000000015d453b35cb523095da1bdd087d788", + "0x000000000000000000000000000000f0038d9a9acf1b4f08fd384f73555d992a", + "0x00000000000000000000000000000000002a5916ff6f77368f00e27ffae348a2", + "0x0000000000000000000000000000001fbc7da3e43c92cd5c222c0a5110b583b5", + "0x000000000000000000000000000000000030227502aa8cdfa15452130b05f9e2", + "0x000000000000000000000000000000fbdfd671d0c02ccc7810114ab1d8df3aef", + "0x00000000000000000000000000000000000fee77f7a266bf78678dfb0fb1e9e1", + "0x000000000000000000000000000000e5bd9eec079f9b0c23a7104b5bc61ea63e", + "0x0000000000000000000000000000000000109cd00aae63694c002f41acbb96d7", + "0x0000000000000000000000000000003ee0abb01d4fa17976ba3efe665d72a2e1", + "0x000000000000000000000000000000000000ac0ec029786d7f8944e44270ef4d", + "0x0000000000000000000000000000009a3ae255b2f19a6238782945786d4028ce", + "0x00000000000000000000000000000000002cc7abdf9c27d92fc1ee2cda14a9ba", + "0x00000000000000000000000000000022460d28d93b778fbaf0e4387b1d4671e0", + "0x000000000000000000000000000000000019a8a6bb2563af3217ece000438b61", + "0x000000000000000000000000000000f6684177813b0420369158fb008ca9ed1c", + "0x00000000000000000000000000000000000335080eeedd367f988668e4788b54", + "0x0000000000000000000000000000003545c0cf9e10b59daab4c71d89c37d978b", + "0x00000000000000000000000000000000002106dfd562685db66b6fe3c5e9573b", + "0x000000000000000000000000000000eb65d6937a511f480f7f5d7ac805a2f7e2", + "0x0000000000000000000000000000000000069c9fe9f50c777128416ab06b27eb", + "0x000000000000000000000000000000577ea815b0fdf5fc38c60443f1010ea404", + "0x00000000000000000000000000000000000721a9a9517860e45c200bc7b5656b" ] - hash = "0x06b2006cb3575a42771e0becfe866fcfcef2d52af8bc19f613cabdb3122f2dc7" + hash = "0x227ea6d4336f178d19a6c3a96a9c67886365943c547eba8bc3264352c58d49b5" [[inputs.previous_rollups]] proof = [ @@ -1202,17 +1238,17 @@ proof = [ [inputs.previous_rollups.public_inputs] timestamp = "0x0000000000000000000000000000000000000000000000000000000000000186" - block_headers_hash = "0x1edf89104e7d3c14c92c5789cd10e293b3cb0e2f812e155b8277de808ec600ac" - in_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" - out_hash = "0x009be21298b4428b38b9b314446eef3243121c400edd3780e34da475ea5f17c3" + block_headers_hash = "0x08e15c28fca76a1965118974159f01d5b290d2239e693ecb1b2b0eca054572c3" + is_first_block = false + out_hash = "0x00fab7a43a18caf54d1e3dd82cf6d3def175265507c701576b015603f4dd1b44" accumulated_fees = "0x0000000000000000000000000000000000000000000000000000000000000000" - accumulated_mana_used = "0x0000000000000000000000000000000000000000000000000000000000000000" + accumulated_mana_used = "0x000000000000000000000000000000000000000000000000000000000006b6c0" [inputs.previous_rollups.public_inputs.constants] chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" version = "0x0000000000000000000000000000000000000000000000000000000000000000" - vk_tree_root = "0x11065543c9a42eac842466277ee9149b27403e398e94c6bba4f525931a2ac6bc" - protocol_contracts_hash = "0x24b2bd6e0456d2d2e64beb505010896a57017c6dedf7516d314d551720c3e6b4" + vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c" + protocol_contracts_hash = "0x0727efc9473643b7abbe3c57df72d68e86b244b99cae71b17553c0f937ea433b" prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" slot_number = "0x000000000000000000000000000000000000000000000000000000000000000f" @@ -1227,77 +1263,113 @@ proof = [ fee_per_l2_gas = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.previous_archive] - root = "0x02c1e55021910a8552fe034bd1dad5769dec59fc837d88b03d9cf7a8bba0a348" + root = "0x117aeecc54e82e86461b9fdcf0a0b047ec63a08ecbf4701f5e0898efafa79b29" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000003" [inputs.previous_rollups.public_inputs.new_archive] - root = "0x1c2e04bddbe15b7083e383373e684a691f0687736114926f9500d315a5ea25e0" + root = "0x0f3332b2d40b13dff5cfa371f988c6ded2734b4b97f43c80a38544d93010ffde" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000004" [inputs.previous_rollups.public_inputs.start_state.l1_to_l2_message_tree] -root = "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" +root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.start_state.partial.note_hash_tree] -root = "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449" +root = "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000080" [inputs.previous_rollups.public_inputs.start_state.partial.nullifier_tree] -root = "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8" +root = "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000100" [inputs.previous_rollups.public_inputs.start_state.partial.public_data_tree] -root = "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f" -next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000fe" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollups.public_inputs.end_state.l1_to_l2_message_tree] -root = "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922" +root = "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000400" [inputs.previous_rollups.public_inputs.end_state.partial.note_hash_tree] -root = "0x0058e56291a20ba5208dec6c4e6f93513a7e475709e9292d09b7ca1c7147703e" +root = "0x144f9224dee4aac6eddc5d988e7c6965528d2e08db91cf58989655a68fbfcc52" next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000c0" [inputs.previous_rollups.public_inputs.end_state.partial.nullifier_tree] -root = "0x06d941e09284387689272aef891ff6ec71993e808f3a832c4d1fd74955b1901e" +root = "0x191d19a6ad2b7bba03d122035938544f5e65de24aeaa436cd5e4d977bd014505" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000140" [inputs.previous_rollups.public_inputs.end_state.partial.public_data_tree] -root = "0x069ad5cd9f6b5ac53ec9533083d53fb0e3b8cc49b13211bd6d314c00493971c2" -next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000013d" +root = "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759" +next_available_leaf_index = "0x00000000000000000000000000000000000000000000000000000000000000bf" [inputs.previous_rollups.public_inputs.start_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000aa3" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000a25" [inputs.previous_rollups.public_inputs.start_sponge_blob.sponge] cache = [ - "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8", - "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f", - "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449" + "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00", + "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759", + "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b" ] state = [ - "0x15da51316f6d05717039ebdac951746a67f2039305acba3dde6937f37537a3be", - "0x18d3719d0b48c48b53ca67a10f27a44337f426a5765bad3dacedaacfb6ccac97", - "0x14aff5482ea838000d13644e493656299d3e8d89a40030dbe5ca9bfc7ca80e9b", - "0x101f0785768c74cde83892e08bc25e14d7aff6304b2281bbcdee77377417c602" + "0x135c92350c7353b08f2cb63fded7ce4c854c495584ef333288940d669ce6a599", + "0x21b216cea5b04aad8cdf1f5d9722403e9c7bc282a3a779e4ffe3f1de6c993da9", + "0x21ab5208b30e3512fa415157976f94403dbbfad370f532e03abcbfb2d8b0ac61", + "0x19b5e475d9036a98cc36422f737a08e3eb651f24b19706f6a11087216ddf4a0b" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000002" squeeze_mode = false [inputs.previous_rollups.public_inputs.end_sponge_blob] - num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000ff4" + num_absorbed_fields = "0x0000000000000000000000000000000000000000000000000000000000000ef8" [inputs.previous_rollups.public_inputs.end_sponge_blob.sponge] cache = [ - "0x069ad5cd9f6b5ac53ec9533083d53fb0e3b8cc49b13211bd6d314c00493971c2", - "0x0058e56291a20ba5208dec6c4e6f93513a7e475709e9292d09b7ca1c7147703e", - "0x06d941e09284387689272aef891ff6ec71993e808f3a832c4d1fd74955b1901e" + "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759", + "0x144f9224dee4aac6eddc5d988e7c6965528d2e08db91cf58989655a68fbfcc52", + "0x191d19a6ad2b7bba03d122035938544f5e65de24aeaa436cd5e4d977bd014505" +] + state = [ + "0x0f42af7cb1e7c7a5d9eeb002031ab4bfaa2183df21df8aea26e3e2d6e7ddf1ef", + "0x1a5e05c937c6eb8d395e6f103856fb500ec79c64f7d97d62f5ec997006fd683b", + "0x2ca50979d5bf53faeb621122da601850801d726ee944594a1425177b3512f5e8", + "0x2682a4ee5971b4125a3696db1324f45575d863b85a866b32d05a5ceaa42c2351" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false + + [inputs.previous_rollups.public_inputs.start_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.previous_rollups.public_inputs.start_msg_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" +] + state = [ + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false + + [inputs.previous_rollups.public_inputs.end_msg_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.previous_rollups.public_inputs.end_msg_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" ] state = [ - "0x0409fd0cb5e0dd58444dad20a67900c2695b87d8f5e2d34be195b93bb7bf673e", - "0x2031bb478bec714f835ec97bb9667f9693b45aa727a624108a69a733d7167b12", - "0x10704cd8a3f1cf73d4d1db112c9d7ead399f9e9ff45f555829c80df54f8048d4", - "0x23f69a4ac36e7f859000638fcf61bb6aeda575453ae3995fae7cc2236b7cbd01" + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" ] cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" squeeze_mode = false @@ -1305,60 +1377,60 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 [inputs.previous_rollups.vk_data] leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000e" sibling_path = [ - "0x06b2006cb3575a42771e0becfe866fcfcef2d52af8bc19f613cabdb3122f2dc7", - "0x279cfadc25df7db3e8d0a15e10ff6e5f4bcb741888255ef55ded2c7e7f364ffe", - "0x1944964394682423d7fc879430c65da6feda679bf7aba3c1e99a6cbd464ada9a", - "0x0481dbd69f3e084904030eb9771134ae7be848ec7b4af69e75933270ceeb544d", - "0x1fe698f1a6368c855525a9abcc3713bb49b1dec627f796bf4e23cc86473621ec", - "0x1c7b07f7b3f8344fece2e6a10bc9480dc4b90f89d2a51f344bee80ca5a4bda6e", - "0x12ed8e93726f8b5b79d1291566a72c1775861d60bba2daa19edb3f28d0ae7a3e" + "0x227ea6d4336f178d19a6c3a96a9c67886365943c547eba8bc3264352c58d49b5", + "0x2d7f66d8c425cb437f6ffa40846cb4973f850fb874bf2590bb58aa28730171bd", + "0x1b222531f0055fae25fdfaf1f505d1659b8279dcd4d0f333ca8905cc8aa9661d", + "0x0787c8cc4cfb80390c27cdc17cb24ae198faad7989508690070b3cf40a2ae4fd", + "0x134e9973b03d62389ee6021d35e61158807c7da3c3e6a052d365f53ab1ac214d", + "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", + "0x19dc50e83dfaeddfc1eb7b19cfcf39ef4b5608eecfaf54180697ea982b7bebbd" ] [inputs.previous_rollups.vk_data.vk] key = [ "0x0000000000000000000000000000000000000000000000000000000000000014", - "0x0000000000000000000000000000000000000000000000000000000000000046", + "0x000000000000000000000000000000000000000000000000000000000000005a", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x000000000000000000000000000000f68447ed8472d9f9aecf573652a9d9a928", - "0x0000000000000000000000000000000000130b78833f316a05f0ac3ebb960dd6", - "0x000000000000000000000000000000b1b7566b1bdad938d7329c4055a9d3b44b", - "0x00000000000000000000000000000000000f95bf795c56af943937121ccabb11", - "0x0000000000000000000000000000007e871cbdb15c3280bb41589af6d4bf4600", - "0x0000000000000000000000000000000000005841a06f458a5220f323f6e67389", - "0x00000000000000000000000000000037a8be1964e1c1bf15fa90bbade2ae533e", - "0x00000000000000000000000000000000002fd8adf54cbe47073d8c68ab7231c7", - "0x0000000000000000000000000000007e2dfa58dd9e40bb6ee06db57e6892ad8e", - "0x0000000000000000000000000000000000228189c3a773ff5454da3c52426f43", - "0x000000000000000000000000000000ce262d6729da8006583c8f4a499313308d", - "0x0000000000000000000000000000000000121dc58a8b11eda0e11e988dc148f3", - "0x000000000000000000000000000000d483c67a2dd422d558a2bc6a0dc65c5441", - "0x00000000000000000000000000000000001436c8685ec282c19bacd9671e3424", - "0x000000000000000000000000000000505cfbf25a6b529a79d93da8a67a535226", - "0x0000000000000000000000000000000000277d585acb24a736a24c1c8715e0aa", - "0x0000000000000000000000000000000f71609653b0671afa25e611656d7024e2", - "0x000000000000000000000000000000000026075d31cd834975ea2ca0b120b383", - "0x000000000000000000000000000000307b6f68e4b5f4b0b1f1c7bf03a5442d7c", - "0x00000000000000000000000000000000001ef258df94844ef33b6ebc66098df9", - "0x000000000000000000000000000000366ab50465812874d088c1c47734295381", - "0x0000000000000000000000000000000000065332753549245a04b0f54d60d47d", - "0x00000000000000000000000000000016902f2c8fd7591bd62d52226e951c25b0", - "0x00000000000000000000000000000000002c90216fa88bb7b51a01c3ef4a320e", - "0x000000000000000000000000000000bbb432c76b363d49388741cd8557e22106", - "0x00000000000000000000000000000000002565b0ddbf8d6afaa067b84cb1f12e", - "0x000000000000000000000000000000974b3ad2190f2582dda8748859d47859a0", - "0x00000000000000000000000000000000000b31cf0fb5ec5e6d8541057aa4e2f2", - "0x000000000000000000000000000000025960f9968c5bbf83d3f7a484672b98d8", - "0x000000000000000000000000000000000013026001fd1b1981ad17e862f15a34", - "0x0000000000000000000000000000006e292910e9382851ed4de1b3ee3474c02c", - "0x00000000000000000000000000000000000c2fb93933722953cc5775728b35ec", + "0x00000000000000000000000000000044d68e54f0f94f1cf395e7c7d4ed02b238", + "0x0000000000000000000000000000000000002ee96658546b0c543a5d430da998", + "0x000000000000000000000000000000564bc81720dc91120507a2def4491092cf", + "0x00000000000000000000000000000000002b2ec3dd36d022598f954229813967", + "0x0000000000000000000000000000004c06d035cf278f725500dcaade0de71ed4", + "0x0000000000000000000000000000000000032fe14547859827d72d2c0f43dc38", + "0x00000000000000000000000000000085a9efc398f8a8294803bfde3a1a474627", + "0x0000000000000000000000000000000000303acbcbc42d96acc341e53f525066", + "0x000000000000000000000000000000eacadf1e4fc9cf94b000c78570648f94a9", + "0x000000000000000000000000000000000017da175a88d4cc504f36571d6be0a7", + "0x000000000000000000000000000000f2fda41446f354477c821611b285421c8e", + "0x0000000000000000000000000000000000260a965a88b462bcced56bf6974d08", + "0x000000000000000000000000000000397b2137b0b270d0c2cc4d18b1384f166c", + "0x00000000000000000000000000000000001d5c0b36d8d0781c8991f03d446edb", + "0x000000000000000000000000000000aac9770ef26858570cf042edfe012b444e", + "0x00000000000000000000000000000000000d6f6187315353550fbe644e24b050", + "0x000000000000000000000000000000abd46071b17c397827d4e1ba0307d8cba1", + "0x000000000000000000000000000000000025e627dd9efd18cf1e565ade13621d", + "0x000000000000000000000000000000c7258d6820665a198ec8086e66545e470b", + "0x0000000000000000000000000000000000077dd961b194280cb7691c6d04c274", + "0x00000000000000000000000000000080286d8d49511ab44d99b69d1846c4bd27", + "0x000000000000000000000000000000000011fdc84cd60154742436498a764fc5", + "0x00000000000000000000000000000008132d24e4e5c83672627ee152da55c750", + "0x00000000000000000000000000000000000931a4104f2d70e9767e3cccd132eb", + "0x000000000000000000000000000000116cadf3b52f0509d339b6f7a5e7e7aabd", + "0x00000000000000000000000000000000000e354128a095b2ed068d7de6f665a3", + "0x00000000000000000000000000000011bc19c825f982c113c7acf7bb8ed94524", + "0x000000000000000000000000000000000024ab57f9717b66d505f8beb6a4e587", + "0x0000000000000000000000000000006a9879d743a9607b726b0e202a51c1313d", + "0x000000000000000000000000000000000009aa5187256b95db33b5af499ea13b", + "0x00000000000000000000000000000061b783d2d113c3cb6faaaf0abf0544087b", + "0x00000000000000000000000000000000002d7f93fc44d38067aef8ea4fd80484", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x000000000000000000000000000000239e2f11ea91c867d7080a159fc15e5711", - "0x000000000000000000000000000000000020983a3f65fd98715524f3be6a4d48", - "0x0000000000000000000000000000006251dee2124c8e8689c942362741d1b770", - "0x00000000000000000000000000000000002990e25ef65b37a0c14b2a53e370aa", + "0x00000000000000000000000000000084be7f5e9e18b50c67dcef8b8fa9ee4804", + "0x000000000000000000000000000000000002513625a2968a87c51c5d88d11b0e", + "0x000000000000000000000000000000af0e6c84b6c2045f8ceb8466fdb3500569", + "0x000000000000000000000000000000000004bb378792157bab68a4726e120730", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -1379,60 +1451,650 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x0000000000000000000000000000005202c34600815583df0c2d0e0b711d9da9", - "0x000000000000000000000000000000000013c8db79f7fdf811172fde1144dee9", - "0x00000000000000000000000000000052109b26b144a2cdc1af4e5e60c04be21a", - "0x00000000000000000000000000000000002393c00b1515c1404d7d61513a265f", - "0x0000000000000000000000000000007241727fbbf4010a2c843195cdbeafd157", - "0x00000000000000000000000000000000000a795ef6998b55f779b66ac9d12933", - "0x0000000000000000000000000000001aee6f0314cb405e0bb90e540c1d4b5825", - "0x0000000000000000000000000000000000224ad4b3d1292b0599b3a2d611f162", - "0x000000000000000000000000000000f91ff5901f79ce2e9d2658719987ab0623", - "0x00000000000000000000000000000000001805237be733c97c8936141b767f20", - "0x000000000000000000000000000000a463dafbf5544b77b523e6d0b2e184f1b7", - "0x00000000000000000000000000000000000dd5ca5243a5f9287374bfe50d7231", - "0x000000000000000000000000000000d9d38a9ffb02c68fde1512e5bd4c4c14a1", - "0x00000000000000000000000000000000001feb05f2a116d8eb36aa9d0d39a059", - "0x00000000000000000000000000000036722e643e3ae6ed827a7a3545cb08d7af", - "0x00000000000000000000000000000000002a3543973beaa6206a0c0a81bc4d00", - "0x000000000000000000000000000000df116db890832c4330270e033c9c5b4672", - "0x000000000000000000000000000000000023249bec10f97d4e917ac37cd51f84", - "0x0000000000000000000000000000008c2ac8784c4c7231ef13cf8a40238cde28", - "0x00000000000000000000000000000000001a796365a3f5248fe27f83bbdfc204", - "0x0000000000000000000000000000004d37afbe9da8f90b8baf6fc91e16d8d686", - "0x0000000000000000000000000000000000239d7a93793b18511f1718afa60011", - "0x0000000000000000000000000000006553c4d22e787acd03956f3b68568d5af6", - "0x000000000000000000000000000000000019f0fa65aacb4f914e73a29b12ff95", - "0x00000000000000000000000000000021f7c2075b834340682cd55e057cd40797", - "0x000000000000000000000000000000000020cf3ed909b8b916f364f3e092d695", - "0x000000000000000000000000000000560c871bf2b8a17f94e0ee25d928b95ba5", - "0x000000000000000000000000000000000024ae77e31b4f17dd55e0eec865690d", - "0x00000000000000000000000000000084690b7ac3d1dddfcaa97b06bda3931daf", - "0x00000000000000000000000000000000002e5eea7caf51d4bf55b60a155b924a", - "0x0000000000000000000000000000004739db956c4c8cadd30b1ddf710b76bef3", - "0x00000000000000000000000000000000000c167a87058b33567470ed345dd62c", + "0x000000000000000000000000000000880a0402b902666144d253148f5c57cfd9", + "0x000000000000000000000000000000000023e13a3496037798a5d94d990be193", + "0x00000000000000000000000000000035d8436db6d3f7dbb6ebeb8f647e4b31c6", + "0x00000000000000000000000000000000002fcd4fe87263a6b3eb740c5b09c338", + "0x0000000000000000000000000000004ed3932a39727815356f22ab5a818c828b", + "0x0000000000000000000000000000000000048e5e0ff760b7dfa818c8e76a159e", + "0x000000000000000000000000000000f75ac7ec3cf99410a896d519b4359991a0", + "0x000000000000000000000000000000000014b426d7b923a1e51e00e628ea33eb", + "0x000000000000000000000000000000680c477df52676af3092564e4f2ef70929", + "0x000000000000000000000000000000000012f4671a00ae0f41d93803ba204d24", + "0x0000000000000000000000000000007671a32b47ce15f4207123d6e7c3477339", + "0x00000000000000000000000000000000002cedcbbe89dd1934fa5cced41d2687", + "0x000000000000000000000000000000266171c09327444ee5f3597e883a4b8928", + "0x000000000000000000000000000000000019b3fb66fc967a6f98739b83e26cc3", + "0x0000000000000000000000000000003cee5735f126691f6c4c78b3dbce71ede3", + "0x000000000000000000000000000000000002d6ca762270d9072249a18a7d88e9", + "0x000000000000000000000000000000579304c1a087a3552906fbdf3cc4f72752", + "0x00000000000000000000000000000000000eeb615cafcf06fbe8ca6cadbaad98", + "0x000000000000000000000000000000a1a6b7c0bac457137c03cf055f94148781", + "0x0000000000000000000000000000000000035bb62ee5abdf2533bf141abb0e2b", + "0x000000000000000000000000000000dbed5e4ce4be4fd8619920d659dc2cb92c", + "0x0000000000000000000000000000000000170738f7a38c19f59b34d0652c3312", + "0x0000000000000000000000000000002d44fd0b8149195da9fd52b5d2f83673b4", + "0x0000000000000000000000000000000000069435e483e40881efa4c937cd29e8", + "0x000000000000000000000000000000b28afc8d3b1be86930695e0148ca85bc19", + "0x0000000000000000000000000000000000150dc4a8714c625277cb5b93410416", + "0x000000000000000000000000000000512d57cc0bcd0e7c1f83c340d40570a9ef", + "0x00000000000000000000000000000000001be751db469d4180270183c2d153df", + "0x000000000000000000000000000000465eb6490fba4495211f2eefc95f8dd390", + "0x00000000000000000000000000000000000345b78970b204243c9feef0116304", + "0x000000000000000000000000000000325d0e1cf9804d81e201efdbf0e0534f80", + "0x00000000000000000000000000000000000001b079dc34ce57c60bbcab5fbc6f", + "0x0000000000000000000000000000002f737349acd708f652d1395ec24e6bae8f", + "0x000000000000000000000000000000000016ff6e92a36cc3ead49533122e1875", + "0x00000000000000000000000000000006e089e19422ac6b65abb0c2ca3b23ad20", + "0x000000000000000000000000000000000025d99a605ea8b014cf35e28fa731fd", + "0x000000000000000000000000000000de64891268c56114f4aadcd05c2a60fc30", + "0x00000000000000000000000000000000002f9f6ba3fe20f8dfd3b3332ae43134", + "0x000000000000000000000000000000304ac112a4aa9ec4b19d06384ae94dea4d", + "0x000000000000000000000000000000000023e45ccd742de1c766eb8364927490", + "0x0000000000000000000000000000000124b733669c1d8f4dbfbd7307add42403", + "0x00000000000000000000000000000000000e24f7e09ce59b0f82db30a2508360", + "0x0000000000000000000000000000005d17b2c9ce75d650a711716697123f791e", + "0x000000000000000000000000000000000004e9209e259427de68f42ad700a207", + "0x000000000000000000000000000000b96183042f35312491e5a812d6e16309ed", + "0x000000000000000000000000000000000029bc95d76242598f3c1af447b04433", + "0x000000000000000000000000000000574664dd37ab985fc5bcb6ebe808b154a9", + "0x00000000000000000000000000000000000d6772a2fbb94e932537ce081dd558", + "0x000000000000000000000000000000920371aad6c0d93f30e172a027c4744641", + "0x00000000000000000000000000000000002b8b52dcd59061cef70ef70cc2b91b", + "0x00000000000000000000000000000055ec30e15b0e2b24f395f538cdc7a6ae02", + "0x00000000000000000000000000000000001ea971f73c04c47683c62e6553b6d7" +] + hash = "0x155cff86f825326297a0cab7be11b73de2f60861977b08a76395b27b53212633" + +[inputs.inbox_parity] +proof = [ + "0x0000000000000000000000000000000000000000000000000000000000000001", + "0x0000000000000000000000000000000000000000000000000000000000000002", + "0x0000000000000000000000000000000000000000000000000000000000000003", + "0x0000000000000000000000000000000000000000000000000000000000000004", + "0x0000000000000000000000000000000000000000000000000000000000000005", + "0x0000000000000000000000000000000000000000000000000000000000000006", + "0x0000000000000000000000000000000000000000000000000000000000000007", + "0x0000000000000000000000000000000000000000000000000000000000000008", + "0x0000000000000000000000000000000000000000000000000000000000000009", + "0x000000000000000000000000000000000000000000000000000000000000000a", + "0x000000000000000000000000000000000000000000000000000000000000000b", + "0x000000000000000000000000000000000000000000000000000000000000000c", + "0x000000000000000000000000000000000000000000000000000000000000000d", + "0x000000000000000000000000000000000000000000000000000000000000000e", + "0x000000000000000000000000000000000000000000000000000000000000000f", + "0x0000000000000000000000000000000000000000000000000000000000000010", + "0x0000000000000000000000000000000000000000000000000000000000000011", + "0x0000000000000000000000000000000000000000000000000000000000000012", + "0x0000000000000000000000000000000000000000000000000000000000000013", + "0x0000000000000000000000000000000000000000000000000000000000000014", + "0x0000000000000000000000000000000000000000000000000000000000000015", + "0x0000000000000000000000000000000000000000000000000000000000000016", + "0x0000000000000000000000000000000000000000000000000000000000000017", + "0x0000000000000000000000000000000000000000000000000000000000000018", + "0x0000000000000000000000000000000000000000000000000000000000000019", + "0x000000000000000000000000000000000000000000000000000000000000001a", + "0x000000000000000000000000000000000000000000000000000000000000001b", + "0x000000000000000000000000000000000000000000000000000000000000001c", + "0x000000000000000000000000000000000000000000000000000000000000001d", + "0x000000000000000000000000000000000000000000000000000000000000001e", + "0x000000000000000000000000000000000000000000000000000000000000001f", + "0x0000000000000000000000000000000000000000000000000000000000000020", + "0x0000000000000000000000000000000000000000000000000000000000000021", + "0x0000000000000000000000000000000000000000000000000000000000000022", + "0x0000000000000000000000000000000000000000000000000000000000000023", + "0x0000000000000000000000000000000000000000000000000000000000000024", + "0x0000000000000000000000000000000000000000000000000000000000000025", + "0x0000000000000000000000000000000000000000000000000000000000000026", + "0x0000000000000000000000000000000000000000000000000000000000000027", + "0x0000000000000000000000000000000000000000000000000000000000000028", + "0x0000000000000000000000000000000000000000000000000000000000000029", + "0x000000000000000000000000000000000000000000000000000000000000002a", + "0x000000000000000000000000000000000000000000000000000000000000002b", + "0x000000000000000000000000000000000000000000000000000000000000002c", + "0x000000000000000000000000000000000000000000000000000000000000002d", + "0x000000000000000000000000000000000000000000000000000000000000002e", + "0x000000000000000000000000000000000000000000000000000000000000002f", + "0x0000000000000000000000000000000000000000000000000000000000000030", + "0x0000000000000000000000000000000000000000000000000000000000000031", + "0x0000000000000000000000000000000000000000000000000000000000000032", + "0x0000000000000000000000000000000000000000000000000000000000000033", + "0x0000000000000000000000000000000000000000000000000000000000000034", + "0x0000000000000000000000000000000000000000000000000000000000000035", + "0x0000000000000000000000000000000000000000000000000000000000000036", + "0x0000000000000000000000000000000000000000000000000000000000000037", + "0x0000000000000000000000000000000000000000000000000000000000000038", + "0x0000000000000000000000000000000000000000000000000000000000000039", + "0x000000000000000000000000000000000000000000000000000000000000003a", + "0x000000000000000000000000000000000000000000000000000000000000003b", + "0x000000000000000000000000000000000000000000000000000000000000003c", + "0x000000000000000000000000000000000000000000000000000000000000003d", + "0x000000000000000000000000000000000000000000000000000000000000003e", + "0x000000000000000000000000000000000000000000000000000000000000003f", + "0x0000000000000000000000000000000000000000000000000000000000000040", + "0x0000000000000000000000000000000000000000000000000000000000000041", + "0x0000000000000000000000000000000000000000000000000000000000000042", + "0x0000000000000000000000000000000000000000000000000000000000000043", + "0x0000000000000000000000000000000000000000000000000000000000000044", + "0x0000000000000000000000000000000000000000000000000000000000000045", + "0x0000000000000000000000000000000000000000000000000000000000000046", + "0x0000000000000000000000000000000000000000000000000000000000000047", + "0x0000000000000000000000000000000000000000000000000000000000000048", + "0x0000000000000000000000000000000000000000000000000000000000000049", + "0x000000000000000000000000000000000000000000000000000000000000004a", + "0x000000000000000000000000000000000000000000000000000000000000004b", + "0x000000000000000000000000000000000000000000000000000000000000004c", + "0x000000000000000000000000000000000000000000000000000000000000004d", + "0x000000000000000000000000000000000000000000000000000000000000004e", + "0x000000000000000000000000000000000000000000000000000000000000004f", + "0x0000000000000000000000000000000000000000000000000000000000000050", + "0x0000000000000000000000000000000000000000000000000000000000000051", + "0x0000000000000000000000000000000000000000000000000000000000000052", + "0x0000000000000000000000000000000000000000000000000000000000000053", + "0x0000000000000000000000000000000000000000000000000000000000000054", + "0x0000000000000000000000000000000000000000000000000000000000000055", + "0x0000000000000000000000000000000000000000000000000000000000000056", + "0x0000000000000000000000000000000000000000000000000000000000000057", + "0x0000000000000000000000000000000000000000000000000000000000000058", + "0x0000000000000000000000000000000000000000000000000000000000000059", + "0x000000000000000000000000000000000000000000000000000000000000005a", + "0x000000000000000000000000000000000000000000000000000000000000005b", + "0x000000000000000000000000000000000000000000000000000000000000005c", + "0x000000000000000000000000000000000000000000000000000000000000005d", + "0x000000000000000000000000000000000000000000000000000000000000005e", + "0x000000000000000000000000000000000000000000000000000000000000005f", + "0x0000000000000000000000000000000000000000000000000000000000000060", + "0x0000000000000000000000000000000000000000000000000000000000000061", + "0x0000000000000000000000000000000000000000000000000000000000000062", + "0x0000000000000000000000000000000000000000000000000000000000000063", + "0x0000000000000000000000000000000000000000000000000000000000000064", + "0x0000000000000000000000000000000000000000000000000000000000000065", + "0x0000000000000000000000000000000000000000000000000000000000000066", + "0x0000000000000000000000000000000000000000000000000000000000000067", + "0x0000000000000000000000000000000000000000000000000000000000000068", + "0x0000000000000000000000000000000000000000000000000000000000000069", + "0x000000000000000000000000000000000000000000000000000000000000006a", + "0x000000000000000000000000000000000000000000000000000000000000006b", + "0x000000000000000000000000000000000000000000000000000000000000006c", + "0x000000000000000000000000000000000000000000000000000000000000006d", + "0x000000000000000000000000000000000000000000000000000000000000006e", + "0x000000000000000000000000000000000000000000000000000000000000006f", + "0x0000000000000000000000000000000000000000000000000000000000000070", + "0x0000000000000000000000000000000000000000000000000000000000000071", + "0x0000000000000000000000000000000000000000000000000000000000000072", + "0x0000000000000000000000000000000000000000000000000000000000000073", + "0x0000000000000000000000000000000000000000000000000000000000000074", + "0x0000000000000000000000000000000000000000000000000000000000000075", + "0x0000000000000000000000000000000000000000000000000000000000000076", + "0x0000000000000000000000000000000000000000000000000000000000000077", + "0x0000000000000000000000000000000000000000000000000000000000000078", + "0x0000000000000000000000000000000000000000000000000000000000000079", + "0x000000000000000000000000000000000000000000000000000000000000007a", + "0x000000000000000000000000000000000000000000000000000000000000007b", + "0x000000000000000000000000000000000000000000000000000000000000007c", + "0x000000000000000000000000000000000000000000000000000000000000007d", + "0x000000000000000000000000000000000000000000000000000000000000007e", + "0x000000000000000000000000000000000000000000000000000000000000007f", + "0x0000000000000000000000000000000000000000000000000000000000000080", + "0x0000000000000000000000000000000000000000000000000000000000000081", + "0x0000000000000000000000000000000000000000000000000000000000000082", + "0x0000000000000000000000000000000000000000000000000000000000000083", + "0x0000000000000000000000000000000000000000000000000000000000000084", + "0x0000000000000000000000000000000000000000000000000000000000000085", + "0x0000000000000000000000000000000000000000000000000000000000000086", + "0x0000000000000000000000000000000000000000000000000000000000000087", + "0x0000000000000000000000000000000000000000000000000000000000000088", + "0x0000000000000000000000000000000000000000000000000000000000000089", + "0x000000000000000000000000000000000000000000000000000000000000008a", + "0x000000000000000000000000000000000000000000000000000000000000008b", + "0x000000000000000000000000000000000000000000000000000000000000008c", + "0x000000000000000000000000000000000000000000000000000000000000008d", + "0x000000000000000000000000000000000000000000000000000000000000008e", + "0x000000000000000000000000000000000000000000000000000000000000008f", + "0x0000000000000000000000000000000000000000000000000000000000000090", + "0x0000000000000000000000000000000000000000000000000000000000000091", + "0x0000000000000000000000000000000000000000000000000000000000000092", + "0x0000000000000000000000000000000000000000000000000000000000000093", + "0x0000000000000000000000000000000000000000000000000000000000000094", + "0x0000000000000000000000000000000000000000000000000000000000000095", + "0x0000000000000000000000000000000000000000000000000000000000000096", + "0x0000000000000000000000000000000000000000000000000000000000000097", + "0x0000000000000000000000000000000000000000000000000000000000000098", + "0x0000000000000000000000000000000000000000000000000000000000000099", + "0x000000000000000000000000000000000000000000000000000000000000009a", + "0x000000000000000000000000000000000000000000000000000000000000009b", + "0x000000000000000000000000000000000000000000000000000000000000009c", + "0x000000000000000000000000000000000000000000000000000000000000009d", + "0x000000000000000000000000000000000000000000000000000000000000009e", + "0x000000000000000000000000000000000000000000000000000000000000009f", + "0x00000000000000000000000000000000000000000000000000000000000000a0", + "0x00000000000000000000000000000000000000000000000000000000000000a1", + "0x00000000000000000000000000000000000000000000000000000000000000a2", + "0x00000000000000000000000000000000000000000000000000000000000000a3", + "0x00000000000000000000000000000000000000000000000000000000000000a4", + "0x00000000000000000000000000000000000000000000000000000000000000a5", + "0x00000000000000000000000000000000000000000000000000000000000000a6", + "0x00000000000000000000000000000000000000000000000000000000000000a7", + "0x00000000000000000000000000000000000000000000000000000000000000a8", + "0x00000000000000000000000000000000000000000000000000000000000000a9", + "0x00000000000000000000000000000000000000000000000000000000000000aa", + "0x00000000000000000000000000000000000000000000000000000000000000ab", + "0x00000000000000000000000000000000000000000000000000000000000000ac", + "0x00000000000000000000000000000000000000000000000000000000000000ad", + "0x00000000000000000000000000000000000000000000000000000000000000ae", + "0x00000000000000000000000000000000000000000000000000000000000000af", + "0x00000000000000000000000000000000000000000000000000000000000000b0", + "0x00000000000000000000000000000000000000000000000000000000000000b1", + "0x00000000000000000000000000000000000000000000000000000000000000b2", + "0x00000000000000000000000000000000000000000000000000000000000000b3", + "0x00000000000000000000000000000000000000000000000000000000000000b4", + "0x00000000000000000000000000000000000000000000000000000000000000b5", + "0x00000000000000000000000000000000000000000000000000000000000000b6", + "0x00000000000000000000000000000000000000000000000000000000000000b7", + "0x00000000000000000000000000000000000000000000000000000000000000b8", + "0x00000000000000000000000000000000000000000000000000000000000000b9", + "0x00000000000000000000000000000000000000000000000000000000000000ba", + "0x00000000000000000000000000000000000000000000000000000000000000bb", + "0x00000000000000000000000000000000000000000000000000000000000000bc", + "0x00000000000000000000000000000000000000000000000000000000000000bd", + "0x00000000000000000000000000000000000000000000000000000000000000be", + "0x00000000000000000000000000000000000000000000000000000000000000bf", + "0x00000000000000000000000000000000000000000000000000000000000000c0", + "0x00000000000000000000000000000000000000000000000000000000000000c1", + "0x00000000000000000000000000000000000000000000000000000000000000c2", + "0x00000000000000000000000000000000000000000000000000000000000000c3", + "0x00000000000000000000000000000000000000000000000000000000000000c4", + "0x00000000000000000000000000000000000000000000000000000000000000c5", + "0x00000000000000000000000000000000000000000000000000000000000000c6", + "0x00000000000000000000000000000000000000000000000000000000000000c7", + "0x00000000000000000000000000000000000000000000000000000000000000c8", + "0x00000000000000000000000000000000000000000000000000000000000000c9", + "0x00000000000000000000000000000000000000000000000000000000000000ca", + "0x00000000000000000000000000000000000000000000000000000000000000cb", + "0x00000000000000000000000000000000000000000000000000000000000000cc", + "0x00000000000000000000000000000000000000000000000000000000000000cd", + "0x00000000000000000000000000000000000000000000000000000000000000ce", + "0x00000000000000000000000000000000000000000000000000000000000000cf", + "0x00000000000000000000000000000000000000000000000000000000000000d0", + "0x00000000000000000000000000000000000000000000000000000000000000d1", + "0x00000000000000000000000000000000000000000000000000000000000000d2", + "0x00000000000000000000000000000000000000000000000000000000000000d3", + "0x00000000000000000000000000000000000000000000000000000000000000d4", + "0x00000000000000000000000000000000000000000000000000000000000000d5", + "0x00000000000000000000000000000000000000000000000000000000000000d6", + "0x00000000000000000000000000000000000000000000000000000000000000d7", + "0x00000000000000000000000000000000000000000000000000000000000000d8", + "0x00000000000000000000000000000000000000000000000000000000000000d9", + "0x00000000000000000000000000000000000000000000000000000000000000da", + "0x00000000000000000000000000000000000000000000000000000000000000db", + "0x00000000000000000000000000000000000000000000000000000000000000dc", + "0x00000000000000000000000000000000000000000000000000000000000000dd", + "0x00000000000000000000000000000000000000000000000000000000000000de", + "0x00000000000000000000000000000000000000000000000000000000000000df", + "0x00000000000000000000000000000000000000000000000000000000000000e0", + "0x00000000000000000000000000000000000000000000000000000000000000e1", + "0x00000000000000000000000000000000000000000000000000000000000000e2", + "0x00000000000000000000000000000000000000000000000000000000000000e3", + "0x00000000000000000000000000000000000000000000000000000000000000e4", + "0x00000000000000000000000000000000000000000000000000000000000000e5", + "0x00000000000000000000000000000000000000000000000000000000000000e6", + "0x00000000000000000000000000000000000000000000000000000000000000e7", + "0x00000000000000000000000000000000000000000000000000000000000000e8", + "0x00000000000000000000000000000000000000000000000000000000000000e9", + "0x00000000000000000000000000000000000000000000000000000000000000ea", + "0x00000000000000000000000000000000000000000000000000000000000000eb", + "0x00000000000000000000000000000000000000000000000000000000000000ec", + "0x00000000000000000000000000000000000000000000000000000000000000ed", + "0x00000000000000000000000000000000000000000000000000000000000000ee", + "0x00000000000000000000000000000000000000000000000000000000000000ef", + "0x00000000000000000000000000000000000000000000000000000000000000f0", + "0x00000000000000000000000000000000000000000000000000000000000000f1", + "0x00000000000000000000000000000000000000000000000000000000000000f2", + "0x00000000000000000000000000000000000000000000000000000000000000f3", + "0x00000000000000000000000000000000000000000000000000000000000000f4", + "0x00000000000000000000000000000000000000000000000000000000000000f5", + "0x00000000000000000000000000000000000000000000000000000000000000f6", + "0x00000000000000000000000000000000000000000000000000000000000000f7", + "0x00000000000000000000000000000000000000000000000000000000000000f8", + "0x00000000000000000000000000000000000000000000000000000000000000f9", + "0x00000000000000000000000000000000000000000000000000000000000000fa", + "0x00000000000000000000000000000000000000000000000000000000000000fb", + "0x00000000000000000000000000000000000000000000000000000000000000fc", + "0x00000000000000000000000000000000000000000000000000000000000000fd", + "0x00000000000000000000000000000000000000000000000000000000000000fe", + "0x00000000000000000000000000000000000000000000000000000000000000ff", + "0x0000000000000000000000000000000000000000000000000000000000000100", + "0x0000000000000000000000000000000000000000000000000000000000000101", + "0x0000000000000000000000000000000000000000000000000000000000000102", + "0x0000000000000000000000000000000000000000000000000000000000000103", + "0x0000000000000000000000000000000000000000000000000000000000000104", + "0x0000000000000000000000000000000000000000000000000000000000000105", + "0x0000000000000000000000000000000000000000000000000000000000000106", + "0x0000000000000000000000000000000000000000000000000000000000000107", + "0x0000000000000000000000000000000000000000000000000000000000000108", + "0x0000000000000000000000000000000000000000000000000000000000000109", + "0x000000000000000000000000000000000000000000000000000000000000010a", + "0x000000000000000000000000000000000000000000000000000000000000010b", + "0x000000000000000000000000000000000000000000000000000000000000010c", + "0x000000000000000000000000000000000000000000000000000000000000010d", + "0x000000000000000000000000000000000000000000000000000000000000010e", + "0x000000000000000000000000000000000000000000000000000000000000010f", + "0x0000000000000000000000000000000000000000000000000000000000000110", + "0x0000000000000000000000000000000000000000000000000000000000000111", + "0x0000000000000000000000000000000000000000000000000000000000000112", + "0x0000000000000000000000000000000000000000000000000000000000000113", + "0x0000000000000000000000000000000000000000000000000000000000000114", + "0x0000000000000000000000000000000000000000000000000000000000000115", + "0x0000000000000000000000000000000000000000000000000000000000000116", + "0x0000000000000000000000000000000000000000000000000000000000000117", + "0x0000000000000000000000000000000000000000000000000000000000000118", + "0x0000000000000000000000000000000000000000000000000000000000000119", + "0x000000000000000000000000000000000000000000000000000000000000011a", + "0x000000000000000000000000000000000000000000000000000000000000011b", + "0x000000000000000000000000000000000000000000000000000000000000011c", + "0x000000000000000000000000000000000000000000000000000000000000011d", + "0x000000000000000000000000000000000000000000000000000000000000011e", + "0x000000000000000000000000000000000000000000000000000000000000011f", + "0x0000000000000000000000000000000000000000000000000000000000000120", + "0x0000000000000000000000000000000000000000000000000000000000000121", + "0x0000000000000000000000000000000000000000000000000000000000000122", + "0x0000000000000000000000000000000000000000000000000000000000000123", + "0x0000000000000000000000000000000000000000000000000000000000000124", + "0x0000000000000000000000000000000000000000000000000000000000000125", + "0x0000000000000000000000000000000000000000000000000000000000000126", + "0x0000000000000000000000000000000000000000000000000000000000000127", + "0x0000000000000000000000000000000000000000000000000000000000000128", + "0x0000000000000000000000000000000000000000000000000000000000000129", + "0x000000000000000000000000000000000000000000000000000000000000012a", + "0x000000000000000000000000000000000000000000000000000000000000012b", + "0x000000000000000000000000000000000000000000000000000000000000012c", + "0x000000000000000000000000000000000000000000000000000000000000012d", + "0x000000000000000000000000000000000000000000000000000000000000012e", + "0x000000000000000000000000000000000000000000000000000000000000012f", + "0x0000000000000000000000000000000000000000000000000000000000000130", + "0x0000000000000000000000000000000000000000000000000000000000000131", + "0x0000000000000000000000000000000000000000000000000000000000000132", + "0x0000000000000000000000000000000000000000000000000000000000000133", + "0x0000000000000000000000000000000000000000000000000000000000000134", + "0x0000000000000000000000000000000000000000000000000000000000000135", + "0x0000000000000000000000000000000000000000000000000000000000000136", + "0x0000000000000000000000000000000000000000000000000000000000000137", + "0x0000000000000000000000000000000000000000000000000000000000000138", + "0x0000000000000000000000000000000000000000000000000000000000000139", + "0x000000000000000000000000000000000000000000000000000000000000013a", + "0x000000000000000000000000000000000000000000000000000000000000013b", + "0x000000000000000000000000000000000000000000000000000000000000013c", + "0x000000000000000000000000000000000000000000000000000000000000013d", + "0x000000000000000000000000000000000000000000000000000000000000013e", + "0x000000000000000000000000000000000000000000000000000000000000013f", + "0x0000000000000000000000000000000000000000000000000000000000000140", + "0x0000000000000000000000000000000000000000000000000000000000000141", + "0x0000000000000000000000000000000000000000000000000000000000000142", + "0x0000000000000000000000000000000000000000000000000000000000000143", + "0x0000000000000000000000000000000000000000000000000000000000000144", + "0x0000000000000000000000000000000000000000000000000000000000000145", + "0x0000000000000000000000000000000000000000000000000000000000000146", + "0x0000000000000000000000000000000000000000000000000000000000000147", + "0x0000000000000000000000000000000000000000000000000000000000000148", + "0x0000000000000000000000000000000000000000000000000000000000000149", + "0x000000000000000000000000000000000000000000000000000000000000014a", + "0x000000000000000000000000000000000000000000000000000000000000014b", + "0x000000000000000000000000000000000000000000000000000000000000014c", + "0x000000000000000000000000000000000000000000000000000000000000014d", + "0x000000000000000000000000000000000000000000000000000000000000014e", + "0x000000000000000000000000000000000000000000000000000000000000014f", + "0x0000000000000000000000000000000000000000000000000000000000000150", + "0x0000000000000000000000000000000000000000000000000000000000000151", + "0x0000000000000000000000000000000000000000000000000000000000000152", + "0x0000000000000000000000000000000000000000000000000000000000000153", + "0x0000000000000000000000000000000000000000000000000000000000000154", + "0x0000000000000000000000000000000000000000000000000000000000000155", + "0x0000000000000000000000000000000000000000000000000000000000000156", + "0x0000000000000000000000000000000000000000000000000000000000000157", + "0x0000000000000000000000000000000000000000000000000000000000000158", + "0x0000000000000000000000000000000000000000000000000000000000000159", + "0x000000000000000000000000000000000000000000000000000000000000015a", + "0x000000000000000000000000000000000000000000000000000000000000015b", + "0x000000000000000000000000000000000000000000000000000000000000015c", + "0x000000000000000000000000000000000000000000000000000000000000015d", + "0x000000000000000000000000000000000000000000000000000000000000015e", + "0x000000000000000000000000000000000000000000000000000000000000015f", + "0x0000000000000000000000000000000000000000000000000000000000000160", + "0x0000000000000000000000000000000000000000000000000000000000000161", + "0x0000000000000000000000000000000000000000000000000000000000000162", + "0x0000000000000000000000000000000000000000000000000000000000000163", + "0x0000000000000000000000000000000000000000000000000000000000000164", + "0x0000000000000000000000000000000000000000000000000000000000000165", + "0x0000000000000000000000000000000000000000000000000000000000000166", + "0x0000000000000000000000000000000000000000000000000000000000000167", + "0x0000000000000000000000000000000000000000000000000000000000000168", + "0x0000000000000000000000000000000000000000000000000000000000000169", + "0x000000000000000000000000000000000000000000000000000000000000016a", + "0x000000000000000000000000000000000000000000000000000000000000016b", + "0x000000000000000000000000000000000000000000000000000000000000016c", + "0x000000000000000000000000000000000000000000000000000000000000016d", + "0x000000000000000000000000000000000000000000000000000000000000016e", + "0x000000000000000000000000000000000000000000000000000000000000016f", + "0x0000000000000000000000000000000000000000000000000000000000000170", + "0x0000000000000000000000000000000000000000000000000000000000000171", + "0x0000000000000000000000000000000000000000000000000000000000000172", + "0x0000000000000000000000000000000000000000000000000000000000000173", + "0x0000000000000000000000000000000000000000000000000000000000000174", + "0x0000000000000000000000000000000000000000000000000000000000000175", + "0x0000000000000000000000000000000000000000000000000000000000000176", + "0x0000000000000000000000000000000000000000000000000000000000000177", + "0x0000000000000000000000000000000000000000000000000000000000000178", + "0x0000000000000000000000000000000000000000000000000000000000000179", + "0x000000000000000000000000000000000000000000000000000000000000017a", + "0x000000000000000000000000000000000000000000000000000000000000017b", + "0x000000000000000000000000000000000000000000000000000000000000017c", + "0x000000000000000000000000000000000000000000000000000000000000017d", + "0x000000000000000000000000000000000000000000000000000000000000017e", + "0x000000000000000000000000000000000000000000000000000000000000017f", + "0x0000000000000000000000000000000000000000000000000000000000000180", + "0x0000000000000000000000000000000000000000000000000000000000000181", + "0x0000000000000000000000000000000000000000000000000000000000000182", + "0x0000000000000000000000000000000000000000000000000000000000000183", + "0x0000000000000000000000000000000000000000000000000000000000000184", + "0x0000000000000000000000000000000000000000000000000000000000000185", + "0x0000000000000000000000000000000000000000000000000000000000000186", + "0x0000000000000000000000000000000000000000000000000000000000000187", + "0x0000000000000000000000000000000000000000000000000000000000000188", + "0x0000000000000000000000000000000000000000000000000000000000000189", + "0x000000000000000000000000000000000000000000000000000000000000018a", + "0x000000000000000000000000000000000000000000000000000000000000018b", + "0x000000000000000000000000000000000000000000000000000000000000018c", + "0x000000000000000000000000000000000000000000000000000000000000018d", + "0x000000000000000000000000000000000000000000000000000000000000018e", + "0x000000000000000000000000000000000000000000000000000000000000018f", + "0x0000000000000000000000000000000000000000000000000000000000000190", + "0x0000000000000000000000000000000000000000000000000000000000000191", + "0x0000000000000000000000000000000000000000000000000000000000000192", + "0x0000000000000000000000000000000000000000000000000000000000000193", + "0x0000000000000000000000000000000000000000000000000000000000000194", + "0x0000000000000000000000000000000000000000000000000000000000000195", + "0x0000000000000000000000000000000000000000000000000000000000000196", + "0x0000000000000000000000000000000000000000000000000000000000000197", + "0x0000000000000000000000000000000000000000000000000000000000000198", + "0x0000000000000000000000000000000000000000000000000000000000000199", + "0x000000000000000000000000000000000000000000000000000000000000019a" +] + + [inputs.inbox_parity.public_inputs] + in_hash = "0x00aa91330eafec1db9b1ca2e1733b213a28bfde0499aca2506acc8c00aae7ba3" + start_rolling_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" + end_rolling_hash = "0x005b0c15d0f641e148adfec120a12eadbf8343e009d350aa593b6d78dbae9568" + num_msgs = "0x0000000000000000000000000000000000000000000000000000000000000400" + vk_tree_root = "0x0a178ec6fe216bfa6e2d25089ce97f9ff6b5c5701d2bce2a1fdf11e6dc351e3c" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.inbox_parity.public_inputs.start_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000000" + + [inputs.inbox_parity.public_inputs.start_sponge.sponge] + cache = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + state = [ "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000000" + squeeze_mode = false + + [inputs.inbox_parity.public_inputs.end_sponge] + num_absorbed = "0x0000000000000000000000000000000000000000000000000000000000000400" + + [inputs.inbox_parity.public_inputs.end_sponge.sponge] + cache = [ + "0x00000000000000000000000000000000000000000000000000000000000009db", + "0x00000000000000000000000000000000000000000000000000000000000009d9", + "0x00000000000000000000000000000000000000000000000000000000000009da" +] + state = [ + "0x13a801138d16230fb1088f7fd847ded1c4972fb74bd6e7bc356881f054400aa6", + "0x182a8954baa5425098a60fdbd090ff8918a2ea34cd0f7f52b65422bf666ebfcf", + "0x11e3f79645edb7132868adb47ea5361ff65f7b612d23ebd31b2d2e16f8570918", + "0x2f22e68da640d535dbaa64cc7c81e2b36ada1e9bcb891b371f90220e74493ae0" +] + cache_size = "0x0000000000000000000000000000000000000000000000000000000000000001" + squeeze_mode = false + + [inputs.inbox_parity.vk_data] + leaf_index = "0x000000000000000000000000000000000000000000000000000000000000004c" + sibling_path = [ "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x000000000000000000000000000000f358d0d158178b8c1c5d1ab306fc824c6e", - "0x00000000000000000000000000000000001bfd8927e824b9139109755ac78ae8", - "0x0000000000000000000000000000009f633351b5460cd99ae56aa83c0a509e80", - "0x000000000000000000000000000000000007a02b5dd7f155aba055ff7b97cefc", - "0x000000000000000000000000000000b4411838e9bff24af3fd0a5d83f0c11530", - "0x0000000000000000000000000000000000151208bcc3e48a87e85b4589c38db6", - "0x000000000000000000000000000000c97cd77b3a0e92086255723ecaf28d7e38", - "0x00000000000000000000000000000000000200b49f18b0213dd44e92f80d6c8f", - "0x000000000000000000000000000000ca55dc2b5233494a2fec946463b3580977", - "0x000000000000000000000000000000000002f0544254905ba4070d96e3cad8f5", - "0x000000000000000000000000000000a64246255e19fd5bfda22d42dfa6f33a06", - "0x00000000000000000000000000000000000f00cca836c24c894ef5b80652121b", - "0x00000000000000000000000000000064af99efc74cc9f94032445418dfe0ca63", - "0x00000000000000000000000000000000002ccbc5204c523afd51ef21b0d7297a", - "0x000000000000000000000000000000d3014926288a126140b79c57f8a1e3adf4", - "0x00000000000000000000000000000000002ea5f5bf7c4bbd05edf988f1b9319d" + "0x19f1a0c09db4cd026f686e9c8fb45501a9fefb4eb1b4c6c328a51343a0094eeb", + "0x00f0288e12c8d2cfc9a3367452f5cde532eb491b48a9973413f76776f21078d7", + "0x0a1d41f1f9a82ceedcca0a62137d817577e4ff56a352e1fcd6757134719f67df", + "0x1e20ad4181460cbfdc74ca773502c59b890f184efe300ebad895956d318422da", + "0x1434e6e2d5db1053ab8a3be58704509c799ee17e109c77f441f7bf1755400249", + "0x1b82d88b0126f67d4dd805387fb3904a609c9926c1c9f3d4af2d35f6699dd2a8" +] + + [inputs.inbox_parity.vk_data.vk] + key = [ + "0x0000000000000000000000000000000000000000000000000000000000000018", + "0x0000000000000000000000000000000000000000000000000000000000000022", + "0x0000000000000000000000000000000000000000000000000000000000000005", + "0x000000000000000000000000000000328d1319c69d7e686b6ec27f5f8826f1d6", + "0x00000000000000000000000000000000001e5129f05687a0605e92998f362d22", + "0x00000000000000000000000000000016b8afcbfa53d116a63aa18f1305ac5354", + "0x0000000000000000000000000000000000010bb457863dd919b09ffa619278ec", + "0x0000000000000000000000000000000bc57f7730a7234dee675e439d79fdd3ff", + "0x00000000000000000000000000000000000eb3ccd01c8f9bcb569c3678b3bdd4", + "0x000000000000000000000000000000309d4a9ff9c28c81b3ab1ead81e118545a", + "0x000000000000000000000000000000000019e58c2c3d369fb0b5bd0ada5f1a52", + "0x00000000000000000000000000000032511092a06981ce1ac5cb12e6af8810db", + "0x00000000000000000000000000000000002184fb8c96926d717ac8356ef56911", + "0x0000000000000000000000000000000052f31cffba27db7a7697c73a687e798d", + "0x00000000000000000000000000000000000420a44a90550abe8a82948de4c5f5", + "0x000000000000000000000000000000552eb5ce6a1e83ee06636caea6a2505787", + "0x00000000000000000000000000000000001d68e034086c3bfc28287b93be153e", + "0x000000000000000000000000000000e6789f820241265c4a2ceb157cccda0a4f", + "0x00000000000000000000000000000000000ca13ea50c9c14bc0832b16a61e90e", + "0x000000000000000000000000000000407894f08a1839457acf02116214c13436", + "0x000000000000000000000000000000000014e7040f723b2fe2de9060a293d816", + "0x00000000000000000000000000000042387d2cd2b2664d10817060395f5f97d4", + "0x00000000000000000000000000000000000ff13eba3ce3e42ab168a243b27d82", + "0x000000000000000000000000000000e53814528e6d1e7d412387fca7d1f9b594", + "0x00000000000000000000000000000000002be14788e85833b10834b6e4d85ceb", + "0x00000000000000000000000000000034e2888e67d5cffdfb595c8e56b8595e63", + "0x0000000000000000000000000000000000209f3e0bd3ef2b680f2cd7b1e84e51", + "0x000000000000000000000000000000563cc437ecb7156ef5d87468328aaa0cb3", + "0x000000000000000000000000000000000001b5b362f9444dbfeed4f11bacd017", + "0x000000000000000000000000000000ffcf05ed417b3a4bdbe76a5da459d6c82a", + "0x00000000000000000000000000000000002b1da7f6e4bc380b6e35ca49bf5527", + "0x0000000000000000000000000000004dbda1adb8188198a8dcd576d6acd48378", + "0x000000000000000000000000000000000026b09aac709f7c50590491fe646cb6", + "0x0000000000000000000000000000009558d6fd4bdb0435ba53846c8074a6bf71", + "0x00000000000000000000000000000000002d71445044ebbba09bee463d922b78", + "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", + "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", + "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", + "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", + "0x0000000000000000000000000000007d31a1e637b282aecf3a21d0476e5ada2a", + "0x00000000000000000000000000000000000cb87f762b2b5e3f3883b73c1c8454", + "0x000000000000000000000000000000cc0ebf25502a79d92048e99b1f7bf6089a", + "0x000000000000000000000000000000000016200201ae31e2f019b766d6c6c77e", + "0x000000000000000000000000000000ece2ccc928bd0ce9dad4362e0ff8dd69cc", + "0x000000000000000000000000000000000022dc4262de0af1432a4df6b5c0d828", + "0x0000000000000000000000000000001bb52239fb6b68a03690884696453f7725", + "0x000000000000000000000000000000000009f7e8a07b29e1c775b23a666e1d51", + "0x00000000000000000000000000000087250a49d7a2c5e95c5cf96504c7afe932", + "0x00000000000000000000000000000000000be81f5f1e1a7a527d5ab9003aa9c6", + "0x0000000000000000000000000000007fd067241c9169a4c2d51ef5223f04145e", + "0x00000000000000000000000000000000000d62eec848241712d7a74b8a1b3c68", + "0x000000000000000000000000000000a8d2ca5f177c36c219084d36dddc000f83", + "0x00000000000000000000000000000000001cce6c20320da7875f350cf454cc22", + "0x0000000000000000000000000000001eae7070788b005571d12b3a540f96b382", + "0x000000000000000000000000000000000021075b87b825a098dea41fae4a52fc", + "0x00000000000000000000000000000009274d8a5dec6a4606f65d940398c4e84c", + "0x0000000000000000000000000000000000190ebd25195a9d0cc42aa520e32ca0", + "0x000000000000000000000000000000e4f823322afa50800d949ffeca1021b50f", + "0x0000000000000000000000000000000000180fd2df09a5c926d14d683ff7247e", + "0x000000000000000000000000000000f75f78af4ca6ab2b4d1d83ae42d23e6d42", + "0x0000000000000000000000000000000000052b59b0a3c352babfb2ca6fb2dc8b", + "0x000000000000000000000000000000bd2d6785d2f1f1fec8f475ddccefceec78", + "0x0000000000000000000000000000000000096d66f46432fc32317fb12bacbcb2", + "0x000000000000000000000000000000dc325a89c22b0408722be1f1c5785b1f4b", + "0x000000000000000000000000000000000019f69034db6803fd0bf6f717619077", + "0x0000000000000000000000000000002d7bd40a64f03f767a30f2e7fd018d5735", + "0x0000000000000000000000000000000000050d320c00614ec4c19f654d58cece", + "0x00000000000000000000000000000059676dcd87d84ba8724c46dc79d49f47a6", + "0x000000000000000000000000000000000017a1143cf04ef8e3e9a529f1b92770", + "0x000000000000000000000000000000a05aa46f97d4a0f1023bffcb1f77c1438b", + "0x00000000000000000000000000000000000b774fd8023d4876e999b647f05fef", + "0x000000000000000000000000000000a7b4b961805216a888251d68b551356964", + "0x0000000000000000000000000000000000123279dcabc48834b49734e9f2f8a0", + "0x0000000000000000000000000000001a3c5a4221ec46340509ea8b178cecdc08", + "0x0000000000000000000000000000000000288992bc430086e55d9d6cc5ce77ce", + "0x0000000000000000000000000000005409c9549e8beb1965faae93bcbe434daa", + "0x00000000000000000000000000000000002a0890a51aaa4b9f60aabb5bc60542", + "0x000000000000000000000000000000760859693aaf8991a597733a545ab431e6", + "0x00000000000000000000000000000000000f1c39c02aa1b7c229ec9b3eefc391", + "0x0000000000000000000000000000008b2b03962494b503a8ce86b3c232ea87cf", + "0x00000000000000000000000000000000003033c259bfdda849212c239228ee4a", + "0x00000000000000000000000000000030b30a8f93a50fcbc679a3d1168b294587", + "0x00000000000000000000000000000000001c39c0deb6b2b49105998bd64ff7ff", + "0x000000000000000000000000000000a6fa737b040db783952bd5cbdbc6ff0341", + "0x00000000000000000000000000000000002012e88d5d376500aba5240d8f37d4", + "0x000000000000000000000000000000993bb0aca115f36461afada9182663d04a", + "0x000000000000000000000000000000000016a501a6bd071fe93ec57bc01d09e9", + "0x0000000000000000000000000000008e99d84006eec3937117cd3dc54bf467bc", + "0x000000000000000000000000000000000026741ba7278d491cc4ef5f808fd3ed", + "0x00000000000000000000000000000059fd0a6d5caab12a3204ec2f3bb03ea273", + "0x00000000000000000000000000000000000c06a10d5a1f39c0d1ff01a8fedd52", + "0x00000000000000000000000000000087db338a273ef894bdee1298de59c7b9fc", + "0x000000000000000000000000000000000001bda0babe63bfbe1cc8170c26af48", + "0x00000000000000000000000000000076523a3d16889ef1b595d6ee771a54e4ba", + "0x00000000000000000000000000000000002ea89ff682b4d2427dd4ab430382ae", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x000000000000000000000000000000f93f9b3c3ccb03b1d0f59150699f9fa3f9", + "0x00000000000000000000000000000000001ae9fc694057698cfd927a9afe43fb", + "0x0000000000000000000000000000004baef7faea08dc749d788a4c6c9bbe29d2", + "0x00000000000000000000000000000000002cc1f10d4638983f558eecdc6ba39f", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000c2e566a842af127bb2863b28e5c9834dd", + "0x0000000000000000000000000000000000123326d1f3e3f1e6439701c2e4c376", + "0x0000000000000000000000000000001e726d0681305bc36d34999bc9848337c2", + "0x00000000000000000000000000000000001298212e7f4c6f496d44b34cf49805", + "0x000000000000000000000000000000d1ed1e54ab019bd2ca96095e6025ba414f", + "0x000000000000000000000000000000000019227b7d43eb104ef0e6acf3b0f41a", + "0x0000000000000000000000000000006692c1a1cfad8e8fac36fb92129878159f", + "0x00000000000000000000000000000000002e861c2b1aa417701f37425baa8d21" ] - hash = "0x01343c2fd6c1ffb7f74e657666d03b4842aa647357eeafa82c9a740c7ab7c0f5" + hash = "0x09c1c633e0ec0baf5833b43503da14c2cbceaa66180315b0cab7fa5177337e0e" [inputs.hints] previous_archive_sibling_path = [ @@ -1475,74 +2137,9 @@ new_out_hash_sibling_path = [ "0x00089a9d421a82c4a25f7acbebe69e638d5b064fa8a60e018793dcb0be53752c" ] blobs_fields = [ - "0x00000000009c707518004000400008004000400400000000000000000000054b", - "0x2cc074b1c577bf415eedcc3b2f3d7d9b6748d020a20bdea1eb8c5eade8ebb81a", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x00000000000000000000000000000000000000000000000000000000b7d1b000", - "0x00000000000000000000000000000000000000000000000000000000b7d1b001", - "0x00000000000000000000000000000000000000000000000000000000b7d1b002", - "0x00000000000000000000000000000000000000000000000000000000b7d1b003", - "0x00000000000000000000000000000000000000000000000000000000b7d1b004", - "0x00000000000000000000000000000000000000000000000000000000b7d1b005", - "0x00000000000000000000000000000000000000000000000000000000b7d1b006", - "0x00000000000000000000000000000000000000000000000000000000b7d1b007", - "0x00000000000000000000000000000000000000000000000000000000b7d1b008", - "0x00000000000000000000000000000000000000000000000000000000b7d1b009", - "0x00000000000000000000000000000000000000000000000000000000b7d1b00a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b00b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b00c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b00d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b00e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b00f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b011", - "0x00000000000000000000000000000000000000000000000000000000b7d1b012", - "0x00000000000000000000000000000000000000000000000000000000b7d1b013", - "0x00000000000000000000000000000000000000000000000000000000b7d1b014", - "0x00000000000000000000000000000000000000000000000000000000b7d1b015", - "0x00000000000000000000000000000000000000000000000000000000b7d1b016", - "0x00000000000000000000000000000000000000000000000000000000b7d1b017", - "0x00000000000000000000000000000000000000000000000000000000b7d1b018", - "0x00000000000000000000000000000000000000000000000000000000b7d1b019", - "0x00000000000000000000000000000000000000000000000000000000b7d1b01a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b01b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b01c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b01d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b01e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b01f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b020", - "0x00000000000000000000000000000000000000000000000000000000b7d1b021", - "0x00000000000000000000000000000000000000000000000000000000b7d1b022", - "0x00000000000000000000000000000000000000000000000000000000b7d1b023", - "0x00000000000000000000000000000000000000000000000000000000b7d1b024", - "0x00000000000000000000000000000000000000000000000000000000b7d1b025", - "0x00000000000000000000000000000000000000000000000000000000b7d1b026", - "0x00000000000000000000000000000000000000000000000000000000b7d1b027", - "0x00000000000000000000000000000000000000000000000000000000b7d1b028", - "0x00000000000000000000000000000000000000000000000000000000b7d1b029", - "0x00000000000000000000000000000000000000000000000000000000b7d1b02a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b02b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b02c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b02d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b02e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b02f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b030", - "0x00000000000000000000000000000000000000000000000000000000b7d1b031", - "0x00000000000000000000000000000000000000000000000000000000b7d1b032", - "0x00000000000000000000000000000000000000000000000000000000b7d1b033", - "0x00000000000000000000000000000000000000000000000000000000b7d1b034", - "0x00000000000000000000000000000000000000000000000000000000b7d1b035", - "0x00000000000000000000000000000000000000000000000000000000b7d1b036", - "0x00000000000000000000000000000000000000000000000000000000b7d1b037", - "0x00000000000000000000000000000000000000000000000000000000b7d1b038", - "0x00000000000000000000000000000000000000000000000000000000b7d1b039", - "0x00000000000000000000000000000000000000000000000000000000b7d1b03a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b03b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b03c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b03d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b03e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b03f", - "0x00000000000000000000000000000000000000000000000000000000b7d1a001", + "0x00000000009c70751800400040000800010040040000000000000000000004cd", + "0x12006d5090806e6de43332aee6e593838e5321616a8cc843ec86db537d17e604", + "0x0000000000000000000000000000000000000000000000000000000000000000", "0x00000000000000000000000000000000000000000000000000000000b7d1b100", "0x00000000000000000000000000000000000000000000000000000000b7d1b101", "0x00000000000000000000000000000000000000000000000000000000b7d1b102", @@ -1606,1239 +2203,1178 @@ blobs_fields = [ "0x00000000000000000000000000000000000000000000000000000000b7d1b13c", "0x00000000000000000000000000000000000000000000000000000000b7d1b13d", "0x00000000000000000000000000000000000000000000000000000000b7d1b13e", - "0x0032e4d4113845639d851c5eb5a42ad9c3d52322bb37b3931c8e1ebb3e8a6b46", - "0x00fbaab4742e01eef1ac0cc0967ba5186f340121d12ca20ab259bc8469e99300", - "0x001502388e1f106a5273074e7f4ed005b3c04c60c16ac65e039274cfb6db3e34", - "0x0023e6fb97bf6dfb2c127fe30b4cc41fab85965f0da8e20671ba14552f4a9c87", - "0x0031553957913988a49af5a4f3f1a508138dc04495e87769b8d44894fae7c4c7", - "0x00dd5b03d5cb9b9da10cfe0949a77ac0422768a68df447d27834a63302ccac16", - "0x00fe787083a3043eae580b1dcc72c132e7005cb32ecae7ba24f1570758258839", - "0x0014919077fbdf50ec823e2fd61c2c2d7be9486ae036fef5ef10f4b090d9f130", + "0x00000000000000000000000000000000000000000000000000000000b7d1b13f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b200", + "0x00000000000000000000000000000000000000000000000000000000b7d1b201", + "0x00000000000000000000000000000000000000000000000000000000b7d1b202", + "0x00000000000000000000000000000000000000000000000000000000b7d1b203", + "0x00000000000000000000000000000000000000000000000000000000b7d1b204", + "0x00000000000000000000000000000000000000000000000000000000b7d1b205", + "0x00000000000000000000000000000000000000000000000000000000b7d1b206", + "0x00000000000000000000000000000000000000000000000000000000b7d1b207", + "0x00000000000000000000000000000000000000000000000000000000b7d1b208", + "0x00000000000000000000000000000000000000000000000000000000b7d1b209", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b20f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b210", + "0x00000000000000000000000000000000000000000000000000000000b7d1b211", + "0x00000000000000000000000000000000000000000000000000000000b7d1b212", + "0x00000000000000000000000000000000000000000000000000000000b7d1b213", + "0x00000000000000000000000000000000000000000000000000000000b7d1b214", + "0x00000000000000000000000000000000000000000000000000000000b7d1b215", + "0x00000000000000000000000000000000000000000000000000000000b7d1b216", + "0x00000000000000000000000000000000000000000000000000000000b7d1b217", + "0x00000000000000000000000000000000000000000000000000000000b7d1b218", + "0x00000000000000000000000000000000000000000000000000000000b7d1b219", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b21f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b220", + "0x00000000000000000000000000000000000000000000000000000000b7d1b221", + "0x00000000000000000000000000000000000000000000000000000000b7d1b222", + "0x00000000000000000000000000000000000000000000000000000000b7d1b223", + "0x00000000000000000000000000000000000000000000000000000000b7d1b224", + "0x00000000000000000000000000000000000000000000000000000000b7d1b225", + "0x00000000000000000000000000000000000000000000000000000000b7d1b226", + "0x00000000000000000000000000000000000000000000000000000000b7d1b227", + "0x00000000000000000000000000000000000000000000000000000000b7d1b228", + "0x00000000000000000000000000000000000000000000000000000000b7d1b229", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b22f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b230", + "0x00000000000000000000000000000000000000000000000000000000b7d1b231", + "0x00000000000000000000000000000000000000000000000000000000b7d1b232", + "0x00000000000000000000000000000000000000000000000000000000b7d1b233", + "0x00000000000000000000000000000000000000000000000000000000b7d1b234", + "0x00000000000000000000000000000000000000000000000000000000b7d1b235", + "0x00000000000000000000000000000000000000000000000000000000b7d1b236", + "0x00000000000000000000000000000000000000000000000000000000b7d1b237", + "0x00000000000000000000000000000000000000000000000000000000b7d1b238", + "0x00000000000000000000000000000000000000000000000000000000b7d1b239", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b23f", + "0x0014e392e48abf86fbcc646ebd535dcfadddf685f17cea1ad8692d84091fee6c", + "0x0081d7915f280fb0ab3bc1424d1f3b0afe8b13ca662631eb35d42d344b463ca5", + "0x00108dedfcd6e6ec14921619d606d4e274eb020bb1cceaecaabc10591905ccca", + "0x002d49d5a469f7a62cab3d2b266ed8f6bb38dacb2fb848e61cdbd6f174fa4473", + "0x00c9d057674688ddc5b9dce4037f7a173d54d42423831b1f17c7ad345ba12acb", + "0x00d65baedb6181e9f1d19c3e64ae63b26c0df768927d9654153a4312c0bfb8f9", + "0x00baf276002157aa3a0111d9547fd25bfbefd9d1841ffb292d2801e5354e7d05", + "0x002e2d381dbc44262bbafdf7e1645e1642daf94aa6175667bd69b3452c748e41", "0x27d08044a627c19f19b7b033af1c9b13f99160a207c22534c11ce11f88ad6814", "0x0000000000000000000000000000000000000000000000056bc75e2d63100000", - "0x00000000000000000000000000000000000000000000000000000000b7d1c001", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00b", - "0x00000000000000000000000000000000000000000000000000000000b7d1c002", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00c", - "0x00000000000000000000000000000000000000000000000000000000b7d1c003", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00d", - "0x00000000000000000000000000000000000000000000000000000000b7d1c004", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00e", - "0x00000000000000000000000000000000000000000000000000000000b7d1c005", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00f", - "0x00000000000000000000000000000000000000000000000000000000b7d1c006", - "0x00000000000000000000000000000000000000000000000000000000b7d1c010", - "0x00000000000000000000000000000000000000000000000000000000b7d1c007", - "0x00000000000000000000000000000000000000000000000000000000b7d1c011", - "0x00000000000000000000000000000000000000000000000000000000b7d1c008", - "0x00000000000000000000000000000000000000000000000000000000b7d1c012", - "0x00000000000000000000000000000000000000000000000000000000b7d1c009", - "0x00000000000000000000000000000000000000000000000000000000b7d1c013", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00a", - "0x00000000000000000000000000000000000000000000000000000000b7d1c014", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00b", - "0x00000000000000000000000000000000000000000000000000000000b7d1c015", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00c", - "0x00000000000000000000000000000000000000000000000000000000b7d1c016", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00d", - "0x00000000000000000000000000000000000000000000000000000000b7d1c017", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00e", - "0x00000000000000000000000000000000000000000000000000000000b7d1c018", - "0x00000000000000000000000000000000000000000000000000000000b7d1c00f", - "0x00000000000000000000000000000000000000000000000000000000b7d1c019", - "0x00000000000000000000000000000000000000000000000000000000b7d1c010", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01a", - "0x00000000000000000000000000000000000000000000000000000000b7d1c011", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01b", - "0x00000000000000000000000000000000000000000000000000000000b7d1c012", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01c", - "0x00000000000000000000000000000000000000000000000000000000b7d1c013", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01d", - "0x00000000000000000000000000000000000000000000000000000000b7d1c014", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01e", - "0x00000000000000000000000000000000000000000000000000000000b7d1c015", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01f", - "0x00000000000000000000000000000000000000000000000000000000b7d1c016", - "0x00000000000000000000000000000000000000000000000000000000b7d1c020", - "0x00000000000000000000000000000000000000000000000000000000b7d1c017", - "0x00000000000000000000000000000000000000000000000000000000b7d1c021", - "0x00000000000000000000000000000000000000000000000000000000b7d1c018", - "0x00000000000000000000000000000000000000000000000000000000b7d1c022", - "0x00000000000000000000000000000000000000000000000000000000b7d1c019", - "0x00000000000000000000000000000000000000000000000000000000b7d1c023", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01a", - "0x00000000000000000000000000000000000000000000000000000000b7d1c024", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01b", - "0x00000000000000000000000000000000000000000000000000000000b7d1c025", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01c", - "0x00000000000000000000000000000000000000000000000000000000b7d1c026", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01d", - "0x00000000000000000000000000000000000000000000000000000000b7d1c027", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01e", - "0x00000000000000000000000000000000000000000000000000000000b7d1c028", - "0x00000000000000000000000000000000000000000000000000000000b7d1c01f", - "0x00000000000000000000000000000000000000000000000000000000b7d1c029", - "0x00000000000000000000000000000000000000000000000000000000b7d1c020", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02a", - "0x00000000000000000000000000000000000000000000000000000000b7d1c021", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02b", - "0x00000000000000000000000000000000000000000000000000000000b7d1c022", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02c", - "0x00000000000000000000000000000000000000000000000000000000b7d1c023", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02d", - "0x00000000000000000000000000000000000000000000000000000000b7d1c024", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02e", - "0x00000000000000000000000000000000000000000000000000000000b7d1c025", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02f", - "0x00000000000000000000000000000000000000000000000000000000b7d1c026", - "0x00000000000000000000000000000000000000000000000000000000b7d1c030", - "0x00000000000000000000000000000000000000000000000000000000b7d1c027", - "0x00000000000000000000000000000000000000000000000000000000b7d1c031", - "0x00000000000000000000000000000000000000000000000000000000b7d1c028", - "0x00000000000000000000000000000000000000000000000000000000b7d1c032", - "0x00000000000000000000000000000000000000000000000000000000b7d1c029", - "0x00000000000000000000000000000000000000000000000000000000b7d1c033", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02a", - "0x00000000000000000000000000000000000000000000000000000000b7d1c034", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02b", - "0x00000000000000000000000000000000000000000000000000000000b7d1c035", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02c", - "0x00000000000000000000000000000000000000000000000000000000b7d1c036", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02d", - "0x00000000000000000000000000000000000000000000000000000000b7d1c037", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02e", - "0x00000000000000000000000000000000000000000000000000000000b7d1c038", - "0x00000000000000000000000000000000000000000000000000000000b7d1c02f", - "0x00000000000000000000000000000000000000000000000000000000b7d1c039", - "0x00000000000000000000000000000000000000000000000000000000b7d1c030", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03a", - "0x00000000000000000000000000000000000000000000000000000000b7d1c031", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03b", - "0x00000000000000000000000000000000000000000000000000000000b7d1c032", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03c", - "0x00000000000000000000000000000000000000000000000000000000b7d1c033", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03d", - "0x00000000000000000000000000000000000000000000000000000000b7d1c034", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03e", - "0x00000000000000000000000000000000000000000000000000000000b7d1c035", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03f", - "0x00000000000000000000000000000000000000000000000000000000b7d1c036", - "0x00000000000000000000000000000000000000000000000000000000b7d1c040", - "0x00000000000000000000000000000000000000000000000000000000b7d1c037", - "0x00000000000000000000000000000000000000000000000000000000b7d1c041", - "0x00000000000000000000000000000000000000000000000000000000b7d1c038", - "0x00000000000000000000000000000000000000000000000000000000b7d1c042", - "0x00000000000000000000000000000000000000000000000000000000b7d1c039", - "0x00000000000000000000000000000000000000000000000000000000b7d1c043", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03a", - "0x00000000000000000000000000000000000000000000000000000000b7d1c044", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03b", - "0x00000000000000000000000000000000000000000000000000000000b7d1c045", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03c", - "0x00000000000000000000000000000000000000000000000000000000b7d1c046", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03d", - "0x00000000000000000000000000000000000000000000000000000000b7d1c047", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03e", - "0x00000000000000000000000000000000000000000000000000000000b7d1c048", - "0x00000000000000000000000000000000000000000000000000000000b7d1c03f", - "0x00000000000000000000000000000000000000000000000000000000b7d1c049", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b300", - "0x00000000000000000000000000000000000000000000000000000000b7d1b301", - "0x00000000000000000000000000000000000000000000000000000000b7d1b302", - "0x00000000000000000000000000000000000000000000000000000000b7d1b303", - "0x00000000000000000000000000000000000000000000000000000000b7d1b304", - "0x00000000000000000000000000000000000000000000000000000000b7d1b305", - "0x00000000000000000000000000000000000000000000000000000000b7d1b306", - "0x00000000000000000000000000000000000000000000000000000000b7d1b307", - "0x00000000000000000000000000000000000000000000000000000000b7d1b308", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b400", + "0x00000000000000000000000000000000000000000000000000000000b7d1b401", + "0x00000000000000000000000000000000000000000000000000000000b7d1b402", + "0x00000000000000000000000000000000000000000000000000000000b7d1b403", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b301", - "0x00000000000000000000000000000000000000000000000000000000b7d1b302", - "0x00000000000000000000000000000000000000000000000000000000b7d1b303", - "0x00000000000000000000000000000000000000000000000000000000b7d1b304", - "0x00000000000000000000000000000000000000000000000000000000b7d1b305", - "0x00000000000000000000000000000000000000000000000000000000b7d1b306", - "0x00000000000000000000000000000000000000000000000000000000b7d1b307", - "0x00000000000000000000000000000000000000000000000000000000b7d1b308", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", + "0x00000000000000000000000000000000000000000000000000000000b7d1b401", + "0x00000000000000000000000000000000000000000000000000000000b7d1b402", + "0x00000000000000000000000000000000000000000000000000000000b7d1b403", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b302", - "0x00000000000000000000000000000000000000000000000000000000b7d1b303", - "0x00000000000000000000000000000000000000000000000000000000b7d1b304", - "0x00000000000000000000000000000000000000000000000000000000b7d1b305", - "0x00000000000000000000000000000000000000000000000000000000b7d1b306", - "0x00000000000000000000000000000000000000000000000000000000b7d1b307", - "0x00000000000000000000000000000000000000000000000000000000b7d1b308", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", + "0x00000000000000000000000000000000000000000000000000000000b7d1b402", + "0x00000000000000000000000000000000000000000000000000000000b7d1b403", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b303", - "0x00000000000000000000000000000000000000000000000000000000b7d1b304", - "0x00000000000000000000000000000000000000000000000000000000b7d1b305", - "0x00000000000000000000000000000000000000000000000000000000b7d1b306", - "0x00000000000000000000000000000000000000000000000000000000b7d1b307", - "0x00000000000000000000000000000000000000000000000000000000b7d1b308", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", + "0x00000000000000000000000000000000000000000000000000000000b7d1b403", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b304", - "0x00000000000000000000000000000000000000000000000000000000b7d1b305", - "0x00000000000000000000000000000000000000000000000000000000b7d1b306", - "0x00000000000000000000000000000000000000000000000000000000b7d1b307", - "0x00000000000000000000000000000000000000000000000000000000b7d1b308", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", + "0x00000000000000000000000000000000000000000000000000000000b7d1b404", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b305", - "0x00000000000000000000000000000000000000000000000000000000b7d1b306", - "0x00000000000000000000000000000000000000000000000000000000b7d1b307", - "0x00000000000000000000000000000000000000000000000000000000b7d1b308", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", + "0x00000000000000000000000000000000000000000000000000000000b7d1b405", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b306", - "0x00000000000000000000000000000000000000000000000000000000b7d1b307", - "0x00000000000000000000000000000000000000000000000000000000b7d1b308", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", + "0x00000000000000000000000000000000000000000000000000000000b7d1b406", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b307", - "0x00000000000000000000000000000000000000000000000000000000b7d1b308", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", + "0x00000000000000000000000000000000000000000000000000000000b7d1b407", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b308", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", + "0x00000000000000000000000000000000000000000000000000000000b7d1b408", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b309", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", + "0x00000000000000000000000000000000000000000000000000000000b7d1b409", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b30f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b40f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b310", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b410", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b311", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", + "0x00000000000000000000000000000000000000000000000000000000b7d1b411", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b312", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", + "0x00000000000000000000000000000000000000000000000000000000b7d1b412", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b313", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", + "0x00000000000000000000000000000000000000000000000000000000b7d1b413", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b314", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", + "0x00000000000000000000000000000000000000000000000000000000b7d1b414", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b315", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", + "0x00000000000000000000000000000000000000000000000000000000b7d1b415", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b316", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", + "0x00000000000000000000000000000000000000000000000000000000b7d1b416", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b317", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", + "0x00000000000000000000000000000000000000000000000000000000b7d1b417", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b318", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", + "0x00000000000000000000000000000000000000000000000000000000b7d1b418", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b319", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", + "0x00000000000000000000000000000000000000000000000000000000b7d1b419", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b31f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b41f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b320", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b420", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b321", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", + "0x00000000000000000000000000000000000000000000000000000000b7d1b421", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b322", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", + "0x00000000000000000000000000000000000000000000000000000000b7d1b422", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b323", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", + "0x00000000000000000000000000000000000000000000000000000000b7d1b423", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b324", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", + "0x00000000000000000000000000000000000000000000000000000000b7d1b424", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b325", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", + "0x00000000000000000000000000000000000000000000000000000000b7d1b425", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b326", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", + "0x00000000000000000000000000000000000000000000000000000000b7d1b426", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b327", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", + "0x00000000000000000000000000000000000000000000000000000000b7d1b427", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b328", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", + "0x00000000000000000000000000000000000000000000000000000000b7d1b428", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b329", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", + "0x00000000000000000000000000000000000000000000000000000000b7d1b429", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b32f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b42f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b330", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b430", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b331", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", + "0x00000000000000000000000000000000000000000000000000000000b7d1b431", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b332", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", + "0x00000000000000000000000000000000000000000000000000000000b7d1b432", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b333", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", + "0x00000000000000000000000000000000000000000000000000000000b7d1b433", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b334", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", + "0x00000000000000000000000000000000000000000000000000000000b7d1b434", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b335", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", + "0x00000000000000000000000000000000000000000000000000000000b7d1b435", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b336", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", + "0x00000000000000000000000000000000000000000000000000000000b7d1b436", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b337", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", - "0x00000000000000000000000000000000000000000000000000000000b7d1b346", + "0x00000000000000000000000000000000000000000000000000000000b7d1b437", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b338", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", - "0x00000000000000000000000000000000000000000000000000000000b7d1b346", - "0x00000000000000000000000000000000000000000000000000000000b7d1b347", + "0x00000000000000000000000000000000000000000000000000000000b7d1b438", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b339", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", - "0x00000000000000000000000000000000000000000000000000000000b7d1b346", - "0x00000000000000000000000000000000000000000000000000000000b7d1b347", - "0x00000000000000000000000000000000000000000000000000000000b7d1b348", + "0x00000000000000000000000000000000000000000000000000000000b7d1b439", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", - "0x00000000000000000000000000000000000000000000000000000000b7d1b346", - "0x00000000000000000000000000000000000000000000000000000000b7d1b347", - "0x00000000000000000000000000000000000000000000000000000000b7d1b348", - "0x00000000000000000000000000000000000000000000000000000000b7d1b349", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", - "0x00000000000000000000000000000000000000000000000000000000b7d1b346", - "0x00000000000000000000000000000000000000000000000000000000b7d1b347", - "0x00000000000000000000000000000000000000000000000000000000b7d1b348", - "0x00000000000000000000000000000000000000000000000000000000b7d1b349", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", - "0x00000000000000000000000000000000000000000000000000000000b7d1b346", - "0x00000000000000000000000000000000000000000000000000000000b7d1b347", - "0x00000000000000000000000000000000000000000000000000000000b7d1b348", - "0x00000000000000000000000000000000000000000000000000000000b7d1b349", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44b", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", - "0x00000000000000000000000000000000000000000000000000000000b7d1b346", - "0x00000000000000000000000000000000000000000000000000000000b7d1b347", - "0x00000000000000000000000000000000000000000000000000000000b7d1b348", - "0x00000000000000000000000000000000000000000000000000000000b7d1b349", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44c", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33e", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", - "0x00000000000000000000000000000000000000000000000000000000b7d1b346", - "0x00000000000000000000000000000000000000000000000000000000b7d1b347", - "0x00000000000000000000000000000000000000000000000000000000b7d1b348", - "0x00000000000000000000000000000000000000000000000000000000b7d1b349", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44d", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7d1b33f", - "0x00000000000000000000000000000000000000000000000000000000b7d1b340", - "0x00000000000000000000000000000000000000000000000000000000b7d1b341", - "0x00000000000000000000000000000000000000000000000000000000b7d1b342", - "0x00000000000000000000000000000000000000000000000000000000b7d1b343", - "0x00000000000000000000000000000000000000000000000000000000b7d1b344", - "0x00000000000000000000000000000000000000000000000000000000b7d1b345", - "0x00000000000000000000000000000000000000000000000000000000b7d1b346", - "0x00000000000000000000000000000000000000000000000000000000b7d1b347", - "0x00000000000000000000000000000000000000000000000000000000b7d1b348", - "0x00000000000000000000000000000000000000000000000000000000b7d1b349", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34a", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34b", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34c", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34d", - "0x00000000000000000000000000000000000000000000000000000000b7d1b34e", + "0x00000000000000000000000000000000000000000000000000000000b7d1b43f", + "0x00000000000000000000000000000000000000000000000000000000b7d1b440", + "0x00000000000000000000000000000000000000000000000000000000b7d1b441", + "0x00000000000000000000000000000000000000000000000000000000b7d1b442", + "0x00000000000000000000000000000000000000000000000000000000b7d1b443", + "0x00000000000000000000000000000000000000000000000000000000b7d1b444", + "0x00000000000000000000000000000000000000000000000000000000b7d1b445", + "0x00000000000000000000000000000000000000000000000000000000b7d1b446", + "0x00000000000000000000000000000000000000000000000000000000b7d1b447", + "0x00000000000000000000000000000000000000000000000000000000b7d1b448", + "0x00000000000000000000000000000000000000000000000000000000b7d1b449", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44a", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44b", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44c", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44d", + "0x00000000000000000000000000000000000000000000000000000000b7d1b44e", "0x0000000000000000000000000000eb8dcdbf0000000000000186000000010001", - "0x0000000000000000004000000000010000000000c000000000bf000000000000", + "0x0000000000000000004000000000010000000000c0000000008000000006b6c0", "0x0fb2945d3438d906d88a216364dbfe9760e96001343468610e01d18182d493d0", - "0x24543462563d01f3fa7d2995feb0568f0868807616f9135cbcec47610a688576", - "0x0d5183688b388e23b4fe243d466e4d50acaf63d7afa00ca046fe2bf2e83db99d", - "0x27b8cdfd5211a289e0aa40da120fa969649354b3a0084d32d1ba1aca6b16f5b9", - "0x2077efe63b8c3de3bfdbc1e1be837185a8f1d817c8321418fcfe110cd518a922", + "0x01612d24a146efc2df9d815a2f733c17486304424577ffb4232fe4cb0c94e1e7", + "0x2d9141720c810b831246b0e50c0ad9d4b935418ba2ae8a06c395bb80340ee684", + "0x1a90881964e28a92a419f1d8361c14ac147b6f9175c04fdf57dadf0d7ba781c9", + "0x18d6aae3ab4a271abd590cb98267825b70de1e9e5c339356e94ea5fc7feba64b", "0x00000000009c707518004000400008004000400400000000000000000000054b", - "0x2a2bb254a295eb5a145c1723eaec08f9a0e64bfb83a166be67ea270421a4dba3", + "0x0295fcaed5e8f00ce18060ee92f418c30fe51949e1633c3bddb26b92c02abc0a", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x00000000000000000000000000000000000000000000000000000000b7e5c000", "0x00000000000000000000000000000000000000000000000000000000b7e5c001", @@ -4193,79 +4729,14 @@ blobs_fields = [ "0x00000000000000000000000000000000000000000000000000000000b7e5c34d", "0x00000000000000000000000000000000000000000000000000000000b7e5c34e", "0x0000000000000000000000000000eb8dcdbf0000000000000186000000020001", - "0x00000000000000000040000000000200000000010000000000fe000000000000", - "0x2ec9fc22ae7001e2ada488cbd0ea07e1cf7f54e151dc2bb766e561636b02eece", - "0x092658df33d4badeaa54da3bee987ed4b7a973d285a96229bbd71c564cad7449", - "0x2fd0dfe2f0d0f4977a6c6d880237e4462686a8caf9e3eacf34b6a5159feac6f8", - "0x1e18fe9a8c877ed096fe353567b6aef5b3dd4bbd987fec03c759c7cde4b3be5f", - "0x00000000009c707518004000400008004000400400000000000000000000054b", - "0x208bf0543b34224ef7f865f1493a705f2b08d91ff98fd5e410d2d864c34a6e9d", - "0x0000000000000000000000000000000000000000000000000000000000000000", - "0x00000000000000000000000000000000000000000000000000000000b7f9d000", - "0x00000000000000000000000000000000000000000000000000000000b7f9d001", - "0x00000000000000000000000000000000000000000000000000000000b7f9d002", - "0x00000000000000000000000000000000000000000000000000000000b7f9d003", - "0x00000000000000000000000000000000000000000000000000000000b7f9d004", - "0x00000000000000000000000000000000000000000000000000000000b7f9d005", - "0x00000000000000000000000000000000000000000000000000000000b7f9d006", - "0x00000000000000000000000000000000000000000000000000000000b7f9d007", - "0x00000000000000000000000000000000000000000000000000000000b7f9d008", - "0x00000000000000000000000000000000000000000000000000000000b7f9d009", - "0x00000000000000000000000000000000000000000000000000000000b7f9d00a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d00b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d00c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d00d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d00e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d00f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d011", - "0x00000000000000000000000000000000000000000000000000000000b7f9d012", - "0x00000000000000000000000000000000000000000000000000000000b7f9d013", - "0x00000000000000000000000000000000000000000000000000000000b7f9d014", - "0x00000000000000000000000000000000000000000000000000000000b7f9d015", - "0x00000000000000000000000000000000000000000000000000000000b7f9d016", - "0x00000000000000000000000000000000000000000000000000000000b7f9d017", - "0x00000000000000000000000000000000000000000000000000000000b7f9d018", - "0x00000000000000000000000000000000000000000000000000000000b7f9d019", - "0x00000000000000000000000000000000000000000000000000000000b7f9d01a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d01b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d01c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d01d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d01e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d01f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d020", - "0x00000000000000000000000000000000000000000000000000000000b7f9d021", - "0x00000000000000000000000000000000000000000000000000000000b7f9d022", - "0x00000000000000000000000000000000000000000000000000000000b7f9d023", - "0x00000000000000000000000000000000000000000000000000000000b7f9d024", - "0x00000000000000000000000000000000000000000000000000000000b7f9d025", - "0x00000000000000000000000000000000000000000000000000000000b7f9d026", - "0x00000000000000000000000000000000000000000000000000000000b7f9d027", - "0x00000000000000000000000000000000000000000000000000000000b7f9d028", - "0x00000000000000000000000000000000000000000000000000000000b7f9d029", - "0x00000000000000000000000000000000000000000000000000000000b7f9d02a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d02b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d02c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d02d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d02e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d02f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d030", - "0x00000000000000000000000000000000000000000000000000000000b7f9d031", - "0x00000000000000000000000000000000000000000000000000000000b7f9d032", - "0x00000000000000000000000000000000000000000000000000000000b7f9d033", - "0x00000000000000000000000000000000000000000000000000000000b7f9d034", - "0x00000000000000000000000000000000000000000000000000000000b7f9d035", - "0x00000000000000000000000000000000000000000000000000000000b7f9d036", - "0x00000000000000000000000000000000000000000000000000000000b7f9d037", - "0x00000000000000000000000000000000000000000000000000000000b7f9d038", - "0x00000000000000000000000000000000000000000000000000000000b7f9d039", - "0x00000000000000000000000000000000000000000000000000000000b7f9d03a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d03b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d03c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d03d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d03e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d03f", - "0x00000000000000000000000000000000000000000000000000000000b7f9c001", + "0x00000000000000000040000000000200000000010000000000bf000000000000", + "0x2d84822e545f3f6e16012e854f9327cee518281ec5f6925ae461d64328e692ee", + "0x2326bf220c6839c1856478f0c082f0c5883b2baed0bc222a1fa5e1244184c82b", + "0x1e1c597744057b88e39a9780ed087c39b1fc42864e05ef03a59ebd9e96b70b00", + "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759", + "0x00000000009c70751800400040000800010040040000000000000000000004cd", + "0x2b65ddafdb085933096aeaa74c3f45700c87829e8ab6d184bd2b2df846d7bb7a", + "0x0000000000000000000000000000000000000000000000000000000000000000", "0x00000000000000000000000000000000000000000000000000000000b7f9d100", "0x00000000000000000000000000000000000000000000000000000000b7f9d101", "0x00000000000000000000000000000000000000000000000000000000b7f9d102", @@ -4329,1237 +4800,1428 @@ blobs_fields = [ "0x00000000000000000000000000000000000000000000000000000000b7f9d13c", "0x00000000000000000000000000000000000000000000000000000000b7f9d13d", "0x00000000000000000000000000000000000000000000000000000000b7f9d13e", - "0x0014741a44b9f74c2b2a5fd138fd19009e7dfbd6346ef79b8a60ec9ff4a3468c", - "0x00e32fd1dab01ceab175f831ba5d34f008598114ab96bb397eef7daca929e33f", - "0x00561bb437fbc8557398d7e944021b1d8efcf9e54ffec1918c08ccbb1f8e725e", - "0x00352433020e3d49f61eca2b1ef6927d9211c1e42e59152f0a5077edd6b90387", - "0x00786401d7b4bb5f2fe168e6e52a8b664caf8cd1ab4fabb7234e7baee1012e94", - "0x00849e2f73059be0bad79266101e9fed574a9064c7b53aaf7339b1579a96a766", - "0x0052dc5caca760b8f9db01df301bbb8124ed5b5498e7d6a74e86ad80c65deca6", - "0x002f21c2dc506d0e24f4ec325962166c3dbcce10c8b088396832cf6e5cbf37b2", + "0x00000000000000000000000000000000000000000000000000000000b7f9d13f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d200", + "0x00000000000000000000000000000000000000000000000000000000b7f9d201", + "0x00000000000000000000000000000000000000000000000000000000b7f9d202", + "0x00000000000000000000000000000000000000000000000000000000b7f9d203", + "0x00000000000000000000000000000000000000000000000000000000b7f9d204", + "0x00000000000000000000000000000000000000000000000000000000b7f9d205", + "0x00000000000000000000000000000000000000000000000000000000b7f9d206", + "0x00000000000000000000000000000000000000000000000000000000b7f9d207", + "0x00000000000000000000000000000000000000000000000000000000b7f9d208", + "0x00000000000000000000000000000000000000000000000000000000b7f9d209", + "0x00000000000000000000000000000000000000000000000000000000b7f9d20a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d20b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d20c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d20d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d20e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d20f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d210", + "0x00000000000000000000000000000000000000000000000000000000b7f9d211", + "0x00000000000000000000000000000000000000000000000000000000b7f9d212", + "0x00000000000000000000000000000000000000000000000000000000b7f9d213", + "0x00000000000000000000000000000000000000000000000000000000b7f9d214", + "0x00000000000000000000000000000000000000000000000000000000b7f9d215", + "0x00000000000000000000000000000000000000000000000000000000b7f9d216", + "0x00000000000000000000000000000000000000000000000000000000b7f9d217", + "0x00000000000000000000000000000000000000000000000000000000b7f9d218", + "0x00000000000000000000000000000000000000000000000000000000b7f9d219", + "0x00000000000000000000000000000000000000000000000000000000b7f9d21a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d21b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d21c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d21d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d21e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d21f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d220", + "0x00000000000000000000000000000000000000000000000000000000b7f9d221", + "0x00000000000000000000000000000000000000000000000000000000b7f9d222", + "0x00000000000000000000000000000000000000000000000000000000b7f9d223", + "0x00000000000000000000000000000000000000000000000000000000b7f9d224", + "0x00000000000000000000000000000000000000000000000000000000b7f9d225", + "0x00000000000000000000000000000000000000000000000000000000b7f9d226", + "0x00000000000000000000000000000000000000000000000000000000b7f9d227", + "0x00000000000000000000000000000000000000000000000000000000b7f9d228", + "0x00000000000000000000000000000000000000000000000000000000b7f9d229", + "0x00000000000000000000000000000000000000000000000000000000b7f9d22a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d22b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d22c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d22d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d22e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d22f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d230", + "0x00000000000000000000000000000000000000000000000000000000b7f9d231", + "0x00000000000000000000000000000000000000000000000000000000b7f9d232", + "0x00000000000000000000000000000000000000000000000000000000b7f9d233", + "0x00000000000000000000000000000000000000000000000000000000b7f9d234", + "0x00000000000000000000000000000000000000000000000000000000b7f9d235", + "0x00000000000000000000000000000000000000000000000000000000b7f9d236", + "0x00000000000000000000000000000000000000000000000000000000b7f9d237", + "0x00000000000000000000000000000000000000000000000000000000b7f9d238", + "0x00000000000000000000000000000000000000000000000000000000b7f9d239", + "0x00000000000000000000000000000000000000000000000000000000b7f9d23a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d23b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d23c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d23d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d23e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d23f", + "0x0084b68f1635bb4387ad6e0a541458ef06c58c624beb729e208699a1580e8aff", + "0x00cfbe26e3d91220e6444179aafdf21e55ed65a45b9ad6eb3e6204697ebecc38", + "0x006194c01064b216dd159f35c086f972bc217050523a3dcad69db89da2c4b16f", + "0x00d1c527d86109d0bec77b091f384bbc71c295936c72fd57304467c25fa344f6", + "0x00a4e5dc95137053dce3a4e833b68ad65d456f13b61fcce41d2206361d0eb64f", + "0x00b7134c2169cbe7866c2455d5957de65e4ac9d0385041cfe3de74b76c326784", + "0x00568275f4816e273c40bc5217a99a4542db301dea198dde0fbd05afe6fda499", + "0x00cdd42ab3e5dca7b4e52a74e99bde6e9db5d425c792d9a5e0987fc66d0fb45a", "0x27d08044a627c19f19b7b033af1c9b13f99160a207c22534c11ce11f88ad6814", "0x0000000000000000000000000000000000000000000000056bc75e2d63100000", - "0x00000000000000000000000000000000000000000000000000000000b7f9e001", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00b", - "0x00000000000000000000000000000000000000000000000000000000b7f9e002", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00c", - "0x00000000000000000000000000000000000000000000000000000000b7f9e003", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00d", - "0x00000000000000000000000000000000000000000000000000000000b7f9e004", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00e", - "0x00000000000000000000000000000000000000000000000000000000b7f9e005", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00f", - "0x00000000000000000000000000000000000000000000000000000000b7f9e006", - "0x00000000000000000000000000000000000000000000000000000000b7f9e010", - "0x00000000000000000000000000000000000000000000000000000000b7f9e007", - "0x00000000000000000000000000000000000000000000000000000000b7f9e011", - "0x00000000000000000000000000000000000000000000000000000000b7f9e008", - "0x00000000000000000000000000000000000000000000000000000000b7f9e012", - "0x00000000000000000000000000000000000000000000000000000000b7f9e009", - "0x00000000000000000000000000000000000000000000000000000000b7f9e013", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00a", - "0x00000000000000000000000000000000000000000000000000000000b7f9e014", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00b", - "0x00000000000000000000000000000000000000000000000000000000b7f9e015", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00c", - "0x00000000000000000000000000000000000000000000000000000000b7f9e016", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00d", - "0x00000000000000000000000000000000000000000000000000000000b7f9e017", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00e", - "0x00000000000000000000000000000000000000000000000000000000b7f9e018", - "0x00000000000000000000000000000000000000000000000000000000b7f9e00f", - "0x00000000000000000000000000000000000000000000000000000000b7f9e019", - "0x00000000000000000000000000000000000000000000000000000000b7f9e010", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01a", - "0x00000000000000000000000000000000000000000000000000000000b7f9e011", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01b", - "0x00000000000000000000000000000000000000000000000000000000b7f9e012", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01c", - "0x00000000000000000000000000000000000000000000000000000000b7f9e013", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01d", - "0x00000000000000000000000000000000000000000000000000000000b7f9e014", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01e", - "0x00000000000000000000000000000000000000000000000000000000b7f9e015", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01f", - "0x00000000000000000000000000000000000000000000000000000000b7f9e016", - "0x00000000000000000000000000000000000000000000000000000000b7f9e020", - "0x00000000000000000000000000000000000000000000000000000000b7f9e017", - "0x00000000000000000000000000000000000000000000000000000000b7f9e021", - "0x00000000000000000000000000000000000000000000000000000000b7f9e018", - "0x00000000000000000000000000000000000000000000000000000000b7f9e022", - "0x00000000000000000000000000000000000000000000000000000000b7f9e019", - "0x00000000000000000000000000000000000000000000000000000000b7f9e023", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01a", - "0x00000000000000000000000000000000000000000000000000000000b7f9e024", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01b", - "0x00000000000000000000000000000000000000000000000000000000b7f9e025", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01c", - "0x00000000000000000000000000000000000000000000000000000000b7f9e026", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01d", - "0x00000000000000000000000000000000000000000000000000000000b7f9e027", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01e", - "0x00000000000000000000000000000000000000000000000000000000b7f9e028", - "0x00000000000000000000000000000000000000000000000000000000b7f9e01f", - "0x00000000000000000000000000000000000000000000000000000000b7f9e029", - "0x00000000000000000000000000000000000000000000000000000000b7f9e020", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02a", - "0x00000000000000000000000000000000000000000000000000000000b7f9e021", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02b", - "0x00000000000000000000000000000000000000000000000000000000b7f9e022", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02c", - "0x00000000000000000000000000000000000000000000000000000000b7f9e023", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02d", - "0x00000000000000000000000000000000000000000000000000000000b7f9e024", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02e", - "0x00000000000000000000000000000000000000000000000000000000b7f9e025", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02f", - "0x00000000000000000000000000000000000000000000000000000000b7f9e026", - "0x00000000000000000000000000000000000000000000000000000000b7f9e030", - "0x00000000000000000000000000000000000000000000000000000000b7f9e027", - "0x00000000000000000000000000000000000000000000000000000000b7f9e031", - "0x00000000000000000000000000000000000000000000000000000000b7f9e028", - "0x00000000000000000000000000000000000000000000000000000000b7f9e032", - "0x00000000000000000000000000000000000000000000000000000000b7f9e029", - "0x00000000000000000000000000000000000000000000000000000000b7f9e033", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02a", - "0x00000000000000000000000000000000000000000000000000000000b7f9e034", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02b", - "0x00000000000000000000000000000000000000000000000000000000b7f9e035", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02c", - "0x00000000000000000000000000000000000000000000000000000000b7f9e036", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02d", - "0x00000000000000000000000000000000000000000000000000000000b7f9e037", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02e", - "0x00000000000000000000000000000000000000000000000000000000b7f9e038", - "0x00000000000000000000000000000000000000000000000000000000b7f9e02f", - "0x00000000000000000000000000000000000000000000000000000000b7f9e039", - "0x00000000000000000000000000000000000000000000000000000000b7f9e030", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03a", - "0x00000000000000000000000000000000000000000000000000000000b7f9e031", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03b", - "0x00000000000000000000000000000000000000000000000000000000b7f9e032", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03c", - "0x00000000000000000000000000000000000000000000000000000000b7f9e033", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03d", - "0x00000000000000000000000000000000000000000000000000000000b7f9e034", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03e", - "0x00000000000000000000000000000000000000000000000000000000b7f9e035", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03f", - "0x00000000000000000000000000000000000000000000000000000000b7f9e036", - "0x00000000000000000000000000000000000000000000000000000000b7f9e040", - "0x00000000000000000000000000000000000000000000000000000000b7f9e037", - "0x00000000000000000000000000000000000000000000000000000000b7f9e041", - "0x00000000000000000000000000000000000000000000000000000000b7f9e038", - "0x00000000000000000000000000000000000000000000000000000000b7f9e042", - "0x00000000000000000000000000000000000000000000000000000000b7f9e039", - "0x00000000000000000000000000000000000000000000000000000000b7f9e043", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03a", - "0x00000000000000000000000000000000000000000000000000000000b7f9e044", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03b", - "0x00000000000000000000000000000000000000000000000000000000b7f9e045", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03c", - "0x00000000000000000000000000000000000000000000000000000000b7f9e046", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03d", - "0x00000000000000000000000000000000000000000000000000000000b7f9e047", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03e", - "0x00000000000000000000000000000000000000000000000000000000b7f9e048", - "0x00000000000000000000000000000000000000000000000000000000b7f9e03f", - "0x00000000000000000000000000000000000000000000000000000000b7f9e049", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d300", - "0x00000000000000000000000000000000000000000000000000000000b7f9d301", - "0x00000000000000000000000000000000000000000000000000000000b7f9d302", - "0x00000000000000000000000000000000000000000000000000000000b7f9d303", - "0x00000000000000000000000000000000000000000000000000000000b7f9d304", - "0x00000000000000000000000000000000000000000000000000000000b7f9d305", - "0x00000000000000000000000000000000000000000000000000000000b7f9d306", - "0x00000000000000000000000000000000000000000000000000000000b7f9d307", - "0x00000000000000000000000000000000000000000000000000000000b7f9d308", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d400", + "0x00000000000000000000000000000000000000000000000000000000b7f9d401", + "0x00000000000000000000000000000000000000000000000000000000b7f9d402", + "0x00000000000000000000000000000000000000000000000000000000b7f9d403", + "0x00000000000000000000000000000000000000000000000000000000b7f9d404", + "0x00000000000000000000000000000000000000000000000000000000b7f9d405", + "0x00000000000000000000000000000000000000000000000000000000b7f9d406", + "0x00000000000000000000000000000000000000000000000000000000b7f9d407", + "0x00000000000000000000000000000000000000000000000000000000b7f9d408", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d301", - "0x00000000000000000000000000000000000000000000000000000000b7f9d302", - "0x00000000000000000000000000000000000000000000000000000000b7f9d303", - "0x00000000000000000000000000000000000000000000000000000000b7f9d304", - "0x00000000000000000000000000000000000000000000000000000000b7f9d305", - "0x00000000000000000000000000000000000000000000000000000000b7f9d306", - "0x00000000000000000000000000000000000000000000000000000000b7f9d307", - "0x00000000000000000000000000000000000000000000000000000000b7f9d308", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", + "0x00000000000000000000000000000000000000000000000000000000b7f9d401", + "0x00000000000000000000000000000000000000000000000000000000b7f9d402", + "0x00000000000000000000000000000000000000000000000000000000b7f9d403", + "0x00000000000000000000000000000000000000000000000000000000b7f9d404", + "0x00000000000000000000000000000000000000000000000000000000b7f9d405", + "0x00000000000000000000000000000000000000000000000000000000b7f9d406", + "0x00000000000000000000000000000000000000000000000000000000b7f9d407", + "0x00000000000000000000000000000000000000000000000000000000b7f9d408", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d302", - "0x00000000000000000000000000000000000000000000000000000000b7f9d303", - "0x00000000000000000000000000000000000000000000000000000000b7f9d304", - "0x00000000000000000000000000000000000000000000000000000000b7f9d305", - "0x00000000000000000000000000000000000000000000000000000000b7f9d306", - "0x00000000000000000000000000000000000000000000000000000000b7f9d307", - "0x00000000000000000000000000000000000000000000000000000000b7f9d308", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", + "0x00000000000000000000000000000000000000000000000000000000b7f9d402", + "0x00000000000000000000000000000000000000000000000000000000b7f9d403", + "0x00000000000000000000000000000000000000000000000000000000b7f9d404", + "0x00000000000000000000000000000000000000000000000000000000b7f9d405", + "0x00000000000000000000000000000000000000000000000000000000b7f9d406", + "0x00000000000000000000000000000000000000000000000000000000b7f9d407", + "0x00000000000000000000000000000000000000000000000000000000b7f9d408", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d303", - "0x00000000000000000000000000000000000000000000000000000000b7f9d304", - "0x00000000000000000000000000000000000000000000000000000000b7f9d305", - "0x00000000000000000000000000000000000000000000000000000000b7f9d306", - "0x00000000000000000000000000000000000000000000000000000000b7f9d307", - "0x00000000000000000000000000000000000000000000000000000000b7f9d308", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", + "0x00000000000000000000000000000000000000000000000000000000b7f9d403", + "0x00000000000000000000000000000000000000000000000000000000b7f9d404", + "0x00000000000000000000000000000000000000000000000000000000b7f9d405", + "0x00000000000000000000000000000000000000000000000000000000b7f9d406", + "0x00000000000000000000000000000000000000000000000000000000b7f9d407", + "0x00000000000000000000000000000000000000000000000000000000b7f9d408", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d304", - "0x00000000000000000000000000000000000000000000000000000000b7f9d305", - "0x00000000000000000000000000000000000000000000000000000000b7f9d306", - "0x00000000000000000000000000000000000000000000000000000000b7f9d307", - "0x00000000000000000000000000000000000000000000000000000000b7f9d308", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", + "0x00000000000000000000000000000000000000000000000000000000b7f9d404", + "0x00000000000000000000000000000000000000000000000000000000b7f9d405", + "0x00000000000000000000000000000000000000000000000000000000b7f9d406", + "0x00000000000000000000000000000000000000000000000000000000b7f9d407", + "0x00000000000000000000000000000000000000000000000000000000b7f9d408", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d305", - "0x00000000000000000000000000000000000000000000000000000000b7f9d306", - "0x00000000000000000000000000000000000000000000000000000000b7f9d307", - "0x00000000000000000000000000000000000000000000000000000000b7f9d308", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", + "0x00000000000000000000000000000000000000000000000000000000b7f9d405", + "0x00000000000000000000000000000000000000000000000000000000b7f9d406", + "0x00000000000000000000000000000000000000000000000000000000b7f9d407", + "0x00000000000000000000000000000000000000000000000000000000b7f9d408", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d306", - "0x00000000000000000000000000000000000000000000000000000000b7f9d307", - "0x00000000000000000000000000000000000000000000000000000000b7f9d308", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", + "0x00000000000000000000000000000000000000000000000000000000b7f9d406", + "0x00000000000000000000000000000000000000000000000000000000b7f9d407", + "0x00000000000000000000000000000000000000000000000000000000b7f9d408", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d307", - "0x00000000000000000000000000000000000000000000000000000000b7f9d308", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", + "0x00000000000000000000000000000000000000000000000000000000b7f9d407", + "0x00000000000000000000000000000000000000000000000000000000b7f9d408", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d308", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", + "0x00000000000000000000000000000000000000000000000000000000b7f9d408", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d309", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", + "0x00000000000000000000000000000000000000000000000000000000b7f9d409", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d30f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d40f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d310", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d410", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d311", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", + "0x00000000000000000000000000000000000000000000000000000000b7f9d411", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d312", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", + "0x00000000000000000000000000000000000000000000000000000000b7f9d412", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d313", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", + "0x00000000000000000000000000000000000000000000000000000000b7f9d413", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d314", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", + "0x00000000000000000000000000000000000000000000000000000000b7f9d414", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d315", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", + "0x00000000000000000000000000000000000000000000000000000000b7f9d415", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d316", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", + "0x00000000000000000000000000000000000000000000000000000000b7f9d416", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d317", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", + "0x00000000000000000000000000000000000000000000000000000000b7f9d417", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d318", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", + "0x00000000000000000000000000000000000000000000000000000000b7f9d418", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d319", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", + "0x00000000000000000000000000000000000000000000000000000000b7f9d419", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d31f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d41f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d320", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d420", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d321", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", + "0x00000000000000000000000000000000000000000000000000000000b7f9d421", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d322", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", + "0x00000000000000000000000000000000000000000000000000000000b7f9d422", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d323", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", + "0x00000000000000000000000000000000000000000000000000000000b7f9d423", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d324", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", + "0x00000000000000000000000000000000000000000000000000000000b7f9d424", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d325", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", + "0x00000000000000000000000000000000000000000000000000000000b7f9d425", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d326", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", + "0x00000000000000000000000000000000000000000000000000000000b7f9d426", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d327", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", + "0x00000000000000000000000000000000000000000000000000000000b7f9d427", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d328", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", + "0x00000000000000000000000000000000000000000000000000000000b7f9d428", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d329", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", + "0x00000000000000000000000000000000000000000000000000000000b7f9d429", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d32f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d42f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d330", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d430", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d331", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", + "0x00000000000000000000000000000000000000000000000000000000b7f9d431", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d332", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", + "0x00000000000000000000000000000000000000000000000000000000b7f9d432", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d333", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", + "0x00000000000000000000000000000000000000000000000000000000b7f9d433", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d334", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", + "0x00000000000000000000000000000000000000000000000000000000b7f9d434", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d335", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", + "0x00000000000000000000000000000000000000000000000000000000b7f9d435", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d336", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", + "0x00000000000000000000000000000000000000000000000000000000b7f9d436", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d337", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", - "0x00000000000000000000000000000000000000000000000000000000b7f9d346", + "0x00000000000000000000000000000000000000000000000000000000b7f9d437", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", + "0x00000000000000000000000000000000000000000000000000000000b7f9d446", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d338", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", - "0x00000000000000000000000000000000000000000000000000000000b7f9d346", - "0x00000000000000000000000000000000000000000000000000000000b7f9d347", + "0x00000000000000000000000000000000000000000000000000000000b7f9d438", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", + "0x00000000000000000000000000000000000000000000000000000000b7f9d446", + "0x00000000000000000000000000000000000000000000000000000000b7f9d447", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d339", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", - "0x00000000000000000000000000000000000000000000000000000000b7f9d346", - "0x00000000000000000000000000000000000000000000000000000000b7f9d347", - "0x00000000000000000000000000000000000000000000000000000000b7f9d348", + "0x00000000000000000000000000000000000000000000000000000000b7f9d439", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", + "0x00000000000000000000000000000000000000000000000000000000b7f9d446", + "0x00000000000000000000000000000000000000000000000000000000b7f9d447", + "0x00000000000000000000000000000000000000000000000000000000b7f9d448", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", - "0x00000000000000000000000000000000000000000000000000000000b7f9d346", - "0x00000000000000000000000000000000000000000000000000000000b7f9d347", - "0x00000000000000000000000000000000000000000000000000000000b7f9d348", - "0x00000000000000000000000000000000000000000000000000000000b7f9d349", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", + "0x00000000000000000000000000000000000000000000000000000000b7f9d446", + "0x00000000000000000000000000000000000000000000000000000000b7f9d447", + "0x00000000000000000000000000000000000000000000000000000000b7f9d448", + "0x00000000000000000000000000000000000000000000000000000000b7f9d449", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", - "0x00000000000000000000000000000000000000000000000000000000b7f9d346", - "0x00000000000000000000000000000000000000000000000000000000b7f9d347", - "0x00000000000000000000000000000000000000000000000000000000b7f9d348", - "0x00000000000000000000000000000000000000000000000000000000b7f9d349", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", + "0x00000000000000000000000000000000000000000000000000000000b7f9d446", + "0x00000000000000000000000000000000000000000000000000000000b7f9d447", + "0x00000000000000000000000000000000000000000000000000000000b7f9d448", + "0x00000000000000000000000000000000000000000000000000000000b7f9d449", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44a", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", - "0x00000000000000000000000000000000000000000000000000000000b7f9d346", - "0x00000000000000000000000000000000000000000000000000000000b7f9d347", - "0x00000000000000000000000000000000000000000000000000000000b7f9d348", - "0x00000000000000000000000000000000000000000000000000000000b7f9d349", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", + "0x00000000000000000000000000000000000000000000000000000000b7f9d446", + "0x00000000000000000000000000000000000000000000000000000000b7f9d447", + "0x00000000000000000000000000000000000000000000000000000000b7f9d448", + "0x00000000000000000000000000000000000000000000000000000000b7f9d449", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44b", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", - "0x00000000000000000000000000000000000000000000000000000000b7f9d346", - "0x00000000000000000000000000000000000000000000000000000000b7f9d347", - "0x00000000000000000000000000000000000000000000000000000000b7f9d348", - "0x00000000000000000000000000000000000000000000000000000000b7f9d349", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", + "0x00000000000000000000000000000000000000000000000000000000b7f9d446", + "0x00000000000000000000000000000000000000000000000000000000b7f9d447", + "0x00000000000000000000000000000000000000000000000000000000b7f9d448", + "0x00000000000000000000000000000000000000000000000000000000b7f9d449", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44c", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33e", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", - "0x00000000000000000000000000000000000000000000000000000000b7f9d346", - "0x00000000000000000000000000000000000000000000000000000000b7f9d347", - "0x00000000000000000000000000000000000000000000000000000000b7f9d348", - "0x00000000000000000000000000000000000000000000000000000000b7f9d349", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", + "0x00000000000000000000000000000000000000000000000000000000b7f9d446", + "0x00000000000000000000000000000000000000000000000000000000b7f9d447", + "0x00000000000000000000000000000000000000000000000000000000b7f9d448", + "0x00000000000000000000000000000000000000000000000000000000b7f9d449", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44d", "0x0000000000000000000000000000000000000000000000000000000000000010", - "0x00000000000000000000000000000000000000000000000000000000b7f9d33f", - "0x00000000000000000000000000000000000000000000000000000000b7f9d340", - "0x00000000000000000000000000000000000000000000000000000000b7f9d341", - "0x00000000000000000000000000000000000000000000000000000000b7f9d342", - "0x00000000000000000000000000000000000000000000000000000000b7f9d343", - "0x00000000000000000000000000000000000000000000000000000000b7f9d344", - "0x00000000000000000000000000000000000000000000000000000000b7f9d345", - "0x00000000000000000000000000000000000000000000000000000000b7f9d346", - "0x00000000000000000000000000000000000000000000000000000000b7f9d347", - "0x00000000000000000000000000000000000000000000000000000000b7f9d348", - "0x00000000000000000000000000000000000000000000000000000000b7f9d349", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34a", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34b", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34c", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34d", - "0x00000000000000000000000000000000000000000000000000000000b7f9d34e", + "0x00000000000000000000000000000000000000000000000000000000b7f9d43f", + "0x00000000000000000000000000000000000000000000000000000000b7f9d440", + "0x00000000000000000000000000000000000000000000000000000000b7f9d441", + "0x00000000000000000000000000000000000000000000000000000000b7f9d442", + "0x00000000000000000000000000000000000000000000000000000000b7f9d443", + "0x00000000000000000000000000000000000000000000000000000000b7f9d444", + "0x00000000000000000000000000000000000000000000000000000000b7f9d445", + "0x00000000000000000000000000000000000000000000000000000000b7f9d446", + "0x00000000000000000000000000000000000000000000000000000000b7f9d447", + "0x00000000000000000000000000000000000000000000000000000000b7f9d448", + "0x00000000000000000000000000000000000000000000000000000000b7f9d449", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44a", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44b", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44c", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44d", + "0x00000000000000000000000000000000000000000000000000000000b7f9d44e", "0x0000000000000000000000000000eb8dcdbf0000000000000186000000030001", - "0x000000000000000000400000000003000000000140000000013d000000000000", - "0x02c1e55021910a8552fe034bd1dad5769dec59fc837d88b03d9cf7a8bba0a348", - "0x0058e56291a20ba5208dec6c4e6f93513a7e475709e9292d09b7ca1c7147703e", - "0x06d941e09284387689272aef891ff6ec71993e808f3a832c4d1fd74955b1901e", - "0x069ad5cd9f6b5ac53ec9533083d53fb0e3b8cc49b13211bd6d314c00493971c2", - "0x0000000000000000000000000000000000000000000000008c63744300000ff5", + "0x00000000000000000040000000000300000000014000000000bf00000006b6c0", + "0x117aeecc54e82e86461b9fdcf0a0b047ec63a08ecbf4701f5e0898efafa79b29", + "0x144f9224dee4aac6eddc5d988e7c6965528d2e08db91cf58989655a68fbfcc52", + "0x191d19a6ad2b7bba03d122035938544f5e65de24aeaa436cd5e4d977bd014505", + "0x2306af8b455a9cbf87331182183be8c0759fd5e1a4f606cea8a9e24efa461759", + "0x0000000000000000000000000000000000000000000000008c63744300000ef9", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -26052,7 +26714,7 @@ blobs_fields = [ "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000" ] -blobs_hash = "0x00e3f7d54fd4b29292ce7b9ad9435a91f859ca73b7c6353f5efb8c808bb90404" +blobs_hash = "0x00fbc72e348d1a0f41eab7e69d6a4f8051802d738a62d973eb5bb42ea0c67a6f" [inputs.hints.previous_block_header] sponge_blob_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -26139,13 +26801,13 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 ] [inputs.hints.final_blob_challenges] - z = "0x143247d83cc93ed12dcfe7dd29b2e6f7066bf75ed8cce06313d7fbc22a453f57" + z = "0x0db46f47c4d63a98f56b9c264991bff648af4cc854f0c6a5a76b6b86df761456" [inputs.hints.final_blob_challenges.gamma] limbs = [ - "0x7fa40cbbd0c308a3a0455a0dfa22ed", - "0xbcacdb8ffef53c81a217a72a0433b6", - "0x1123" + "0xf6f83cd40c1844dfdaa13808d1d506", + "0x042c3c6ecf32884c61359405f0b61d", + "0x2d10" ] [[inputs.hints.blob_commitments]] @@ -26153,18 +26815,18 @@ next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000 [inputs.hints.blob_commitments.x] limbs = [ - "0xe674754db6e1e252aa3b3d59647753", - "0xc21574d13d87a865e121540f84f4f3", - "0x342975dc6aefdefbc9a9b7054e834e", - "0x0c417c" + "0xcf3fb7c37aa14710885d9b8c4de015", + "0x7801b514d4ea9f906b8ae1aeaee5af", + "0xc749fd4844e7c1330673bf9559f92a", + "0x08d02a" ] [inputs.hints.blob_commitments.y] limbs = [ - "0xefae75ee8dd8ddcaa286e932412b87", - "0xded824efa66ae456595d5b3016dffd", - "0xfe63db91c1e88a22b3b8a9ee439f7e", - "0x0f399f" + "0x7cd018f82b696940e5b7705dfcf238", + "0xf1129e6150a606de408fcec4a83a94", + "0x4f909208f9a2dc50c645d87b13c692", + "0x137c8f" ] [[inputs.hints.blob_commitments]] diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/block_rollup_public_inputs.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/block_rollup_public_inputs.nr index 9600adda08ed..d78a718b3269 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/block_rollup_public_inputs.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/block_rollup_public_inputs.nr @@ -1,3 +1,4 @@ +use crate::abis::L1ToL2MessageSponge; use protocol_test_utils::make_fixture; use types::{ abis::{ @@ -39,9 +40,19 @@ pub struct BlockRollupPublicInputs { // stored in the checkpoint header, enabling validation of the blocks included in a checkpoint given their headers. pub block_headers_hash: Field, - // Root of the `l1_to_l2` message subtree, set in the first block root and propagated to the checkpoint root. - // Block root rollups that are not the first in a checkpoint will have an `in_hash` value of 0. - pub in_hash: Field, + // Whether this block range starts at the first block of its checkpoint. Only the first block root sets this true; + // merges propagate it from the left rollup and `validate_consecutive_block_rollups` asserts the right rollup's is + // false, so it can only reach the checkpoint root through the leftmost leaf. It replaces `in_hash`'s former + // structural role: the checkpoint root asserts the merged value is true, and it drives the block-end blob-absorb + // flag (the l1-to-l2 tree root is absorbed only for the first block). + pub is_first_block: bool, + + // Poseidon2 message-bundle sponge threaded across the blocks of the checkpoint. The leftmost block starts from the + // empty sponge and each block absorbs its bundle's leaves; `validate_consecutive_block_rollups` asserts + // `right.start_msg_sponge == left.end_msg_sponge`, and merges take `start` from the left and `end` from the right. + // The checkpoint root asserts the merged end equals the parity root's sponge over the same (padded) leaf list. + pub start_msg_sponge: L1ToL2MessageSponge, + pub end_msg_sponge: L1ToL2MessageSponge, // Root of the *wonky* tree composed of all tx out hashes in this block. It will be combined with the `out_hash` // values from other blocks within the same checkpoint to form a *wonky* tree. diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/checkpoint_rollup_public_inputs.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/checkpoint_rollup_public_inputs.nr index 9be134f81a4f..9c990d82cba9 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/checkpoint_rollup_public_inputs.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/checkpoint_rollup_public_inputs.nr @@ -29,6 +29,12 @@ pub struct CheckpointRollupPublicInputs { // final epoch out hash inserted into the Outbox on L1. pub new_out_hash: AppendOnlyTreeSnapshot, + // Inbox rolling-hash chain segment consumed by this checkpoint range. `start_inbox_rolling_hash` is the chain value + // before the first checkpoint's messages, `end_inbox_rolling_hash` is the value after the last checkpoint's. The end + // value is what lands in the checkpoint header. Checkpoint merges assert `right.start == left.end` for continuity. + pub start_inbox_rolling_hash: Field, + pub end_inbox_rolling_hash: Field, + // Hashes of checkpoint headers for this checkpoint range. pub checkpoint_header_hashes: [Field; MAX_CHECKPOINTS_PER_EPOCH], @@ -61,6 +67,8 @@ impl Empty for CheckpointRollupPublicInputs { new_archive: AppendOnlyTreeSnapshot::empty(), previous_out_hash: AppendOnlyTreeSnapshot::empty(), new_out_hash: AppendOnlyTreeSnapshot::empty(), + start_inbox_rolling_hash: 0, + end_inbox_rolling_hash: 0, checkpoint_header_hashes: [0; MAX_CHECKPOINTS_PER_EPOCH], fees: [FeeRecipient::empty(); MAX_CHECKPOINTS_PER_EPOCH], start_blob_accumulator: BlobAccumulator::empty(), diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_bundle.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_bundle.nr new file mode 100644 index 000000000000..24b206855625 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_bundle.nr @@ -0,0 +1,29 @@ +use std::meta::derive; +use types::{ + constants::MAX_L1_TO_L2_MSGS_PER_BLOCK, + traits::{Deserialize, Empty, Serialize}, +}; + +/// A block's L1-to-L2 message bundle: the leaves it inserts into the L1-to-L2 message tree, plus the counts a block +/// root needs to append them and absorb them into the message sponge. +/// +/// It carries two counts on purpose. Transitionally the L1-to-L2 tree insert is a fixed padded subtree while the +/// message sponge (and the checkpoint's `InboxParity` proof) work at the real message count, so the two differ: +/// - `num_msgs` — leaves appended to the tree (the padded subtree size for a message-bearing block, 0 for an empty +/// one). +/// - `num_real_msgs` — real (non-padding) messages absorbed into the message sponge. +/// +/// Once the L1-to-L2 tree insert becomes real-count too (the Fast Inbox flip), `num_msgs == num_real_msgs` and +/// `num_real_msgs` is dropped, leaving this struct otherwise unchanged. +#[derive(Deserialize, Eq, Serialize)] +pub struct L1ToL2MessageBundle { + pub messages: [Field; MAX_L1_TO_L2_MSGS_PER_BLOCK], + pub num_msgs: u32, + pub num_real_msgs: u32, +} + +impl Empty for L1ToL2MessageBundle { + fn empty() -> Self { + L1ToL2MessageBundle { messages: [0; MAX_L1_TO_L2_MSGS_PER_BLOCK], num_msgs: 0, num_real_msgs: 0 } + } +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_sponge.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_sponge.nr new file mode 100644 index 000000000000..9f4af934cce7 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_sponge.nr @@ -0,0 +1,116 @@ +use std::meta::derive; +use types::{ + hash::poseidon2_absorb_in_chunks_existing_sponge, + poseidon2::Poseidon2Sponge, + traits::{Deserialize, Empty, Serialize}, +}; + +/// An absorb-only Poseidon2 sponge over L1-to-L2 message leaves. +/// +/// It threads across the blocks of a checkpoint the way `SpongeBlob` threads tx effects: each block absorbs its message +/// bundle into the sponge it inherited from the previous block, and the checkpoint root recomputes the sponge over the +/// flat concatenation of every block's messages and asserts the final states are equal. There are no block separators +/// or markers in the absorbed stream, so the recomputation is identical regardless of how messages were split across +/// blocks. The sponge is never squeezed on the block path — equality of the accumulated state is the only check. +#[derive(Deserialize, Eq, Serialize)] +pub struct L1ToL2MessageSponge { + pub sponge: Poseidon2Sponge, + /// The number of message leaves absorbed so far. + pub num_absorbed: u32, +} + +impl L1ToL2MessageSponge { + pub fn new() -> Self { + Self { sponge: Poseidon2Sponge::new(0), num_absorbed: 0 } + } + + /// Absorb the first `num` leaves of `leaves` in order. Lanes beyond `num` are ignored. + pub fn absorb(&mut self, leaves: [Field; N], num: u32) { + self.sponge = poseidon2_absorb_in_chunks_existing_sponge(self.sponge, leaves, num); + self.num_absorbed += num; + } + + /// Finalize the sponge and output the (non-standard) Poseidon2 hash of all absorbed leaves. + pub fn squeeze(&mut self) -> Field { + self.sponge.squeeze() + } +} + +impl Empty for L1ToL2MessageSponge { + fn empty() -> Self { + Self { sponge: Poseidon2Sponge::new(0), num_absorbed: 0 } + } +} + +mod tests { + use super::L1ToL2MessageSponge; + use types::{poseidon2::Poseidon2Sponge, traits::Empty}; + + #[test] + fn new_equals_empty() { + assert_eq(L1ToL2MessageSponge::new(), L1ToL2MessageSponge::empty()); + assert_eq(L1ToL2MessageSponge::new().num_absorbed, 0); + } + + #[test] + fn absorb_tracks_count() { + let mut sponge = L1ToL2MessageSponge::new(); + sponge.absorb([11, 22, 33, 0, 0], 3); + assert_eq(sponge.num_absorbed, 3); + sponge.absorb([44, 55], 2); + assert_eq(sponge.num_absorbed, 5); + } + + #[test] + fn absorb_ignores_lanes_past_count() { + // Lanes beyond `num` must not affect the accumulated state. + let mut with_padding = L1ToL2MessageSponge::new(); + with_padding.absorb([11, 22, 33, 999, 888], 3); + + let mut exact = L1ToL2MessageSponge::new(); + exact.absorb([11, 22, 33], 3); + + assert_eq(with_padding, exact); + } + + #[test] + fn absorb_equality_across_split_boundaries() { + // Absorbing [11,22,33,44,55] in one call equals absorbing [11,22,33] then [44,55] across two threaded sponges. + let mut single = L1ToL2MessageSponge::new(); + single.absorb([11, 22, 33, 44, 55], 5); + + let mut threaded = L1ToL2MessageSponge::new(); + threaded.absorb([11, 22, 33, 44, 55], 3); + threaded.absorb([44, 55, 0, 0, 0], 2); + + assert_eq(threaded, single); + assert_eq(threaded.num_absorbed, 5); + + let mut single_squeeze = single; + let mut threaded_squeeze = threaded; + assert_eq(threaded_squeeze.squeeze(), single_squeeze.squeeze()); + } + + #[test] + fn empty_bundle_is_noop() { + let mut sponge = L1ToL2MessageSponge::new(); + sponge.absorb([0; 5], 0); + assert_eq(sponge, L1ToL2MessageSponge::empty()); + } + + #[test] + fn matches_raw_poseidon2_sponge() { + // The accumulated state must be a plain absorb-only Poseidon2 sponge with iv = 0. + let mut sponge = L1ToL2MessageSponge::new(); + sponge.absorb([11, 22, 33, 44, 55], 5); + + let mut expected = Poseidon2Sponge::new(0); + expected.absorb(11); + expected.absorb(22); + expected.absorb(33); + expected.absorb(44); + expected.absorb(55); + + assert_eq(sponge.sponge, expected); + } +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/mod.nr index 1ee35685bc37..3a8609d4be2f 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/mod.nr @@ -1,4 +1,8 @@ // TODO: Move to types/src/abis/rollup/ +// `l1_to_l2_message_sponge` is declared first because the `#[derive(Serialize, Deserialize)]` macros require a field +// type's module to be declared before any struct that embeds it (see the ordering note in `types/src/lib.nr`). +mod l1_to_l2_message_sponge; +mod l1_to_l2_message_bundle; mod public_chonk_verifier_public_inputs; mod tx_rollup_public_inputs; mod block_rollup_public_inputs; @@ -8,6 +12,8 @@ mod root_rollup_public_inputs; pub use block_rollup_public_inputs::BlockRollupPublicInputs; pub use checkpoint_rollup_public_inputs::CheckpointRollupPublicInputs; +pub use l1_to_l2_message_bundle::L1ToL2MessageBundle; +pub use l1_to_l2_message_sponge::L1ToL2MessageSponge; pub use parity_public_inputs::ParityPublicInputs; pub use public_chonk_verifier_public_inputs::PublicChonkVerifierPublicInputs; pub use root_rollup_public_inputs::RootRollupPublicInputs; diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/parity_public_inputs.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/parity_public_inputs.nr index 71fe26cdff17..a2260af3e24e 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/parity_public_inputs.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/parity_public_inputs.nr @@ -1,15 +1,42 @@ +use crate::abis::L1ToL2MessageSponge; use types::traits::{Deserialize, Empty, Serialize}; #[derive(Deserialize, Eq, Serialize)] pub struct ParityPublicInputs { - pub sha_root: Field, - pub converted_root: Field, + // The L1 `in_hash`: the sha256 frontier root of the checkpoint's L1-to-L2 messages, checked on L1 against + // `inbox.consume()`. It is an UNCONSTRAINED pass-through: `InboxParity` echoes the value the prover supplies and + // does not recompute it from the messages (the frontier tree is gone from the parity body). Until the Fast Inbox + // flip moves the L1 anchor to the rolling hash, `in_hash` remains the authoritative L1 check, so the prover must + // supply the true frontier root; the in-circuit tie between it and the processed messages is deferred to the flip. + pub in_hash: Field, + // Rolling hash of the Inbox message chain before absorbing this checkpoint's messages. + pub start_rolling_hash: Field, + // Rolling hash of the Inbox message chain after absorbing the `num_msgs` real messages. Each link is + // `sha256ToField(prev || msg)`, matching the truncated-to-field sha256 the L1 Inbox accumulates. + pub end_rolling_hash: Field, + // Poseidon2 message-bundle sponge before this checkpoint's messages (empty at checkpoint start). + pub start_sponge: L1ToL2MessageSponge, + // Message-bundle sponge after absorbing the `num_msgs` real messages. The checkpoint root asserts this equals the + // sponge accumulated across the checkpoint's block roots, tying the parity-committed message list to the leaves + // the blocks inserted into the L1-to-L2 tree. + pub end_sponge: L1ToL2MessageSponge, + // Number of real (non-padding) messages absorbed into the rolling hash and the sponge. + pub num_msgs: u32, pub vk_tree_root: Field, pub prover_id: Field, } impl Empty for ParityPublicInputs { fn empty() -> Self { - ParityPublicInputs { sha_root: 0, converted_root: 0, vk_tree_root: 0, prover_id: 0 } + ParityPublicInputs { + in_hash: 0, + start_rolling_hash: 0, + end_rolling_hash: 0, + start_sponge: L1ToL2MessageSponge::empty(), + end_sponge: L1ToL2MessageSponge::empty(), + num_msgs: 0, + vk_tree_root: 0, + prover_id: 0, + } } } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/root_rollup_public_inputs.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/root_rollup_public_inputs.nr index 33f5e0d2c3c8..925ef68c24dc 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/root_rollup_public_inputs.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/root_rollup_public_inputs.nr @@ -17,6 +17,10 @@ pub struct RootRollupPublicInputs { // Root of the epoch out hash *balanced* tree. // The out hash of the first checkpoint in the epoch is inserted at index 0, the second at index 1, and so on. pub out_hash: Field, + // Inbox rolling-hash chain segment consumed across the epoch: the chain value before the first checkpoint's + // messages and after the last checkpoint's. Continuity within the range is enforced by the checkpoint merges. + pub previous_inbox_rolling_hash: Field, + pub end_inbox_rolling_hash: Field, // Checkpoint header hashes for each checkpoint in this epoch. // The header hash of the first checkpoint in the epoch is at index 0, the second at index 1, and so on. pub checkpoint_header_hashes: [Field; MAX_CHECKPOINTS_PER_EPOCH], diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/block_merge_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/block_merge_rollup.nr index 249fb16561cd..83563c6e8825 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/block_merge_rollup.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/block_merge_rollup.nr @@ -8,17 +8,23 @@ use crate::{ use types::{ constants::{ BLOCK_MERGE_ROLLUP_VK_INDEX, BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX, - BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_ROLLUP_VK_INDEX, - BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, + BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, + BLOCK_ROOT_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, + BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, }, proof::proof_data::RollupHonkProofData, }; // Note: see `rollup_structure_tests.nr` for valid combinations of left and right vks. -global ALLOWED_RIGHT_ROLLUP_VK_INDICES: [u32; 3] = - [BLOCK_ROOT_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, BLOCK_MERGE_ROLLUP_VK_INDEX]; +// The message-only block root is a non-first variant, so it appears alongside the other non-first block roots. +global ALLOWED_RIGHT_ROLLUP_VK_INDICES: [u32; 4] = [ + BLOCK_ROOT_ROLLUP_VK_INDEX, + BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, + BLOCK_MERGE_ROLLUP_VK_INDEX, +]; -global ALLOWED_LEFT_ROLLUP_VK_INDICES: [u32; 6] = ALLOWED_RIGHT_ROLLUP_VK_INDICES.concat([ +global ALLOWED_LEFT_ROLLUP_VK_INDICES: [u32; 7] = ALLOWED_RIGHT_ROLLUP_VK_INDICES.concat([ // The first block roots may only appear as the left child of the block merge rollup. // However, this doesn't prevent having 2 first block roots in the same checkpoint. We rely on the checks in // `validate_consecutive_block_rollups` and `checkpoint_root_inputs_validator` to enforce this. @@ -41,7 +47,7 @@ pub struct BlockMergeRollupPrivateInputs { /// - Merges the state references (left's start with right's end) /// - Merges the sponge blobs (left's start with right's end) /// - Accumulates the block_headers_hash, out_hash, fees, and mana used -/// - Propagates the in_hash from the left rollup (which must be a first block) +/// - Propagates `is_first_block` from the left rollup and threads the message sponge (left's start, right's end) /// /// The output feeds into another Block Merge circuit to continue building the tree, /// or into a Checkpoint Root circuit once all blocks in the checkpoint are combined. diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/consecutive_block_rollups_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/consecutive_block_rollups_tests.nr index 8ac5eba688cc..395c0fed448e 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/consecutive_block_rollups_tests.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/consecutive_block_rollups_tests.nr @@ -1,5 +1,7 @@ use super::TestBuilder; -use types::{address::EthAddress, hash::accumulate_sha256}; +use types::{ + address::EthAddress, constants::BLOCK_ROOT_ROLLUP_VK_INDEX, hash::accumulate_sha256, +}; #[test] fn accumulated_out_hash_correctly() { @@ -54,45 +56,53 @@ fn output_zero_when_both_out_hashes_are_zero() { } #[test] -fn non_zero_in_hash_in_left_rollup() { +fn first_block_in_left_rollup() { + // The default builder has a first block root on the left and a non-first block on the right. let mut builder = TestBuilder::default(); - builder.left_rollup.in_hash = 123; - let pi = builder.execute(); builder.assert_expected_public_inputs(pi); - assert_eq(pi.in_hash, 123); + assert(pi.is_first_block); } #[test] -fn zero_in_hash_in_both_rollups() { - let mut builder = TestBuilder::default(); - - builder.left_rollup.in_hash = 0; - builder.right_rollup.in_hash = 0; +fn no_first_block_in_either_rollup() { + // A merge of two non-first blocks in the middle of a checkpoint carries no first block. + let mut builder = + TestBuilder::new(BLOCK_ROOT_ROLLUP_VK_INDEX, 1, BLOCK_ROOT_ROLLUP_VK_INDEX, 1); let pi = builder.execute(); builder.assert_expected_public_inputs(pi); - assert_eq(pi.in_hash, 0); + assert(!pi.is_first_block); +} + +#[test(should_fail_with = "Right rollup must not be a first block")] +fn first_block_in_right_rollup() { + let mut builder = TestBuilder::default(); + + builder.right_rollup.is_first_block = true; + + builder.execute_and_fail(); } -#[test(should_fail_with = "Right rollup must not carry in_hash")] -fn non_zero_in_hash_in_right_rollup() { +#[test(should_fail_with = "Right rollup must not be a first block")] +fn first_block_in_both_rollups() { let mut builder = TestBuilder::default(); - builder.right_rollup.in_hash = 123; + builder.left_rollup.is_first_block = true; + builder.right_rollup.is_first_block = true; builder.execute_and_fail(); } -#[test(should_fail_with = "Right rollup must not carry in_hash")] -fn non_zero_in_hash_in_both_rollups() { +#[test(should_fail_with = "Mismatched message sponge: expected right.start_msg_sponge to match left.end_msg_sponge")] +fn mismatched_message_sponge_fails() { let mut builder = TestBuilder::default(); - builder.left_rollup.in_hash = 123; - builder.right_rollup.in_hash = 123; + // Break the sponge continuity between the left and right rollups. + builder.right_rollup.start_msg_sponge.num_absorbed += 1; builder.execute_and_fail(); } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/mod.nr index 52d7d174f36e..d1e88b148729 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/mod.nr @@ -1,5 +1,6 @@ mod child_proof_vk_tests; mod consecutive_block_rollups_tests; +mod msgs_only_tests; mod rollup_structure_tests; use crate::{ @@ -13,8 +14,9 @@ use crate::{ use types::{ constants::{ BLOCK_MERGE_ROLLUP_VK_INDEX, BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX, - BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_ROLLUP_VK_INDEX, - BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, + BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, + BLOCK_ROOT_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, + BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, }, hash::accumulate_sha256, }; @@ -58,8 +60,8 @@ impl TestBuilder { if !is_first_block(left_rollup_vk_index) & (left_rollup_vk_index != BLOCK_MERGE_ROLLUP_VK_INDEX) { - // Change the start_block_number to be smaller than the left rollup's start_block_number so that the in_hash - // won't be set on the left rollup. + // Change the start_block_number to be smaller than the left rollup's start_block_number so that + // `is_first_block` won't be set on the left rollup. fixture_builder.start_block_number = start_block_number - 1; } let left_rollup = fixture_builder.get_merged_block_rollup_public_inputs( @@ -68,8 +70,8 @@ impl TestBuilder { ); if is_first_block(right_rollup_vk_index) { - // Change the start_block_number to be the right rollup's start_block_number so that the in_hash will be set - // on the right rollup. + // Change the start_block_number to be the right rollup's start_block_number so that `is_first_block` will be + // set on the right rollup. fixture_builder.start_block_number = start_block_number + num_left_blocks as u32; } let right_rollup = fixture_builder.get_merged_block_rollup_public_inputs( @@ -96,7 +98,8 @@ impl TestBuilder { | (vk_index == BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX) | (vk_index == BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX) | (vk_index == BLOCK_ROOT_ROLLUP_VK_INDEX) - | (vk_index == BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX), + | (vk_index == BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX) + | (vk_index == BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX), ); } } @@ -143,7 +146,11 @@ impl TestBuilder { accumulate_block_headers_hash(left.block_headers_hash, right.block_headers_hash); assert_eq(pi.block_headers_hash, expected_block_headers_hash); - assert_eq(pi.in_hash, left.in_hash); + // `is_first_block` and the start of the message sponge come from the left rollup; the sponge end comes from the + // right rollup. + assert_eq(pi.is_first_block, left.is_first_block); + assert_eq(pi.start_msg_sponge, left.start_msg_sponge); + assert_eq(pi.end_msg_sponge, right.end_msg_sponge); let expected_out_hash = if (left.out_hash != 0) & (right.out_hash != 0) { accumulate_sha256(left.out_hash, right.out_hash) diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/msgs_only_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/msgs_only_tests.nr new file mode 100644 index 000000000000..3de3212dd36d --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/tests/msgs_only_tests.nr @@ -0,0 +1,100 @@ +use crate::{ + abis::BlockRollupPublicInputs, + block_merge::block_merge_rollup::{self, BlockMergeRollupPrivateInputs}, + tests::RollupFixtureBuilder, +}; +use types::constants::{ + BLOCK_MERGE_ROLLUP_VK_INDEX, BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, BLOCK_ROOT_ROLLUP_VK_INDEX, +}; + +// Merges two consecutive single-block rollups into one. +fn merge( + left: BlockRollupPublicInputs, + left_vk_index: u32, + right: BlockRollupPublicInputs, + right_vk_index: u32, +) -> BlockRollupPublicInputs { + block_merge_rollup::execute(BlockMergeRollupPrivateInputs { + previous_rollups: [ + RollupFixtureBuilder::make_proof_data(left, left_vk_index), + RollupFixtureBuilder::make_proof_data(right, right_vk_index), + ], + }) +} + +// The roadmap's done-when: a checkpoint made of [first block, message-only block, normal block] proves. The +// message-only block sits in the middle, so the merge circuits must accept it as a non-first child and thread the state, +// archive and sponges through it. +#[test] +fn checkpoint_with_mid_checkpoint_msgs_only_block() { + let fixture_builder = RollupFixtureBuilder::new(); + let start_block_number = fixture_builder.start_block_number; + + // The consecutive single-block fixtures chain naturally by block number (archives, states and sponges line up). + let first = fixture_builder.get_block_rollup_public_inputs(start_block_number); + let msgs_only = fixture_builder.get_block_rollup_public_inputs(start_block_number + 1); + let normal = fixture_builder.get_block_rollup_public_inputs(start_block_number + 2); + + assert(first.is_first_block); + assert(!msgs_only.is_first_block); + assert(!normal.is_first_block); + + // ((first, msgs_only), normal) + let left = merge( + first, + BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, + msgs_only, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, + ); + let merged = merge(left, BLOCK_MERGE_ROLLUP_VK_INDEX, normal, BLOCK_ROOT_ROLLUP_VK_INDEX); + + assert_eq(merged.num_blocks(), 3); + // `is_first_block` propagates from the leftmost (first) block only. + assert(merged.is_first_block); + assert_eq(merged.previous_archive, first.previous_archive); + assert_eq(merged.new_archive, normal.new_archive); + assert_eq(merged.start_msg_sponge, first.start_msg_sponge); + assert_eq(merged.end_msg_sponge, normal.end_msg_sponge); +} + +// A message-only block is a valid right (non-first) child of a block merge. +#[test] +fn msgs_only_block_accepted_as_right_child() { + let fixture_builder = RollupFixtureBuilder::new(); + let start_block_number = fixture_builder.start_block_number; + + let first = fixture_builder.get_block_rollup_public_inputs(start_block_number); + let msgs_only = fixture_builder.get_block_rollup_public_inputs(start_block_number + 1); + + let merged = merge( + first, + BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, + msgs_only, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, + ); + + assert_eq(merged.num_blocks(), 2); + assert(merged.is_first_block); +} + +// The message-only block's `start_msg_sponge` is a free input; the merge continuity check must catch it if it does not +// follow on from the previous block's `end_msg_sponge`. +#[test(should_fail_with = "Mismatched message sponge: expected right.start_msg_sponge to match left.end_msg_sponge")] +fn msgs_only_block_bad_start_msg_sponge_fails() { + let fixture_builder = RollupFixtureBuilder::new(); + let start_block_number = fixture_builder.start_block_number; + + let first = fixture_builder.get_block_rollup_public_inputs(start_block_number); + let mut msgs_only = fixture_builder.get_block_rollup_public_inputs(start_block_number + 1); + + // Break the sponge continuity with the previous (first) block. + msgs_only.start_msg_sponge.num_absorbed += 1; + + let _ = merge( + first, + BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, + msgs_only, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, + ); +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/utils/merge_block_rollups.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/utils/merge_block_rollups.nr index 8adf08cb1ba3..44cf8b2be5e7 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/utils/merge_block_rollups.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/utils/merge_block_rollups.nr @@ -16,9 +16,15 @@ pub fn merge_block_rollups( let block_headers_hash = accumulate_block_headers_hash(left.block_headers_hash, right.block_headers_hash); - // `in_hash` originates from the first block root and must propagate through all merge steps via the left rollup - // only. It's checked in `validate_consecutive_block_rollups` to make sure only the left rollup carries it. - let in_hash = left.in_hash; + // `is_first_block` originates from the first block root and must propagate through all merge steps via the left + // rollup only. `validate_consecutive_block_rollups` asserts the right rollup's is false, so only the leftmost leaf + // can carry it up to the checkpoint root. + let is_first_block = left.is_first_block; + + // The message sponge threads across the checkpoint's blocks: the range spans left's start through right's end. + // `validate_consecutive_block_rollups` asserts `right.start_msg_sponge == left.end_msg_sponge` for continuity. + let start_msg_sponge = left.start_msg_sponge; + let end_msg_sponge = right.end_msg_sponge; let out_hash = accumulate_out_hash(left.out_hash, right.out_hash); @@ -36,7 +42,9 @@ pub fn merge_block_rollups( end_sponge_blob: right.end_sponge_blob, timestamp: left.timestamp, // Both blocks have the same timestamp. block_headers_hash, - in_hash, + is_first_block, + start_msg_sponge, + end_msg_sponge, out_hash, accumulated_fees, accumulated_mana_used, diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/utils/validate_consecutive_block_rollups.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/utils/validate_consecutive_block_rollups.nr index d01d67845e02..e3e9221d5f8c 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/utils/validate_consecutive_block_rollups.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_merge/utils/validate_consecutive_block_rollups.nr @@ -42,11 +42,17 @@ fn assert_prev_block_rollups_follow_on_from_each_other( "Mismatched timestamps: expected right.timestamp to match left.timestamp", ); - // TODO: Consider extracting into its own function: - - // A non-empty `in_hash` originates from the first block root only, and is propagated through all merge - // steps via the left rollup only (see merge_block_rollups.nr). - // We prevent the right rollup from propagating a nonzero `in_hash`, so it's impossible for any - // block but the first to propagate a nonzero `in_hash` up to the checkpoint root. - assert_eq(right.in_hash, 0, "Right rollup must not carry in_hash"); + // `is_first_block` originates from the first block root only, and is propagated through all merge steps via the + // left rollup only (see merge_block_rollups.nr). We prevent the right rollup from carrying it, so it's impossible + // for any block but the first to propagate `is_first_block == true` up to the checkpoint root. + assert(!right.is_first_block, "Right rollup must not be a first block"); + + // The message sponge threads across the checkpoint's blocks: the right rollup must start from where the left rollup + // ended. Combined with the checkpoint root asserting the leftmost start is empty and the merged end matches the + // parity root's sponge, this pins the blocks to insert exactly the parity-committed message list, in order. + assert_eq( + right.start_msg_sponge, + left.end_msg_sponge, + "Mismatched message sponge: expected right.start_msg_sponge to match left.end_msg_sponge", + ); } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_empty_tx_first_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_empty_tx_first_rollup.nr index a4ecb261edff..4e0ba02a4ee9 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_empty_tx_first_rollup.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_empty_tx_first_rollup.nr @@ -1,19 +1,16 @@ use crate::{ - abis::{BlockRollupPublicInputs, ParityPublicInputs}, - block_root::components::{BlockRollupPublicInputsComposer, validate_parity_root}, + abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge}, + block_root::components::BlockRollupPublicInputsComposer, }; use types::{ abis::{ append_only_tree_snapshot::AppendOnlyTreeSnapshot, checkpoint_constant_data::CheckpointConstantData, state_reference::StateReference, }, - constants::{ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH}, - proof::proof_data::UltraHonkProofData, + constants::{ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT}, }; pub struct BlockRootEmptyTxFirstRollupPrivateInputs { - pub(crate) parity_root: UltraHonkProofData, - pub(crate) previous_archive: AppendOnlyTreeSnapshot, pub(crate) previous_state: StateReference, // The previous block is not in the same checkpoint as the current block. So we need to provide the constants for @@ -23,19 +20,20 @@ pub struct BlockRootEmptyTxFirstRollupPrivateInputs { // timestamp in the checkpoint root. pub(crate) timestamp: u64, - // Hint for inserting the new l1 to l2 message subtree. - pub(crate) new_l1_to_l2_message_subtree_root_sibling_path: [Field; L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH], + // L1-to-L2 message bundle inserted by this block. + pub(crate) message_bundle: L1ToL2MessageBundle, + // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against `previous_state`). + pub(crate) l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT], // Hint for inserting the new block hash to the last archive. pub(crate) new_archive_sibling_path: [Field; ARCHIVE_HEIGHT], } /// The Block Root Empty Tx First Rollup circuit creates the first empty block of a checkpoint. -/// It processes L1-to-L2 messages and creates the block header. +/// It inserts the block's L1-to-L2 message bundle and creates the block header. /// This variant is used for the first block in a checkpoint that contains no transactions. /// /// This circuit: -/// - Verifies the parity root proof containing L1-to-L2 messages for the checkpoint -/// - Inserts the L1-to-L2 message subtree into the L1-to-L2 message tree +/// - Appends the block's L1-to-L2 message bundle to the L1-to-L2 message tree and absorbs it into the message sponge /// - Initializes an empty sponge blob (since it's the first block in a checkpoint) /// - Computes the block header hash and inserts it into the archive tree /// @@ -44,21 +42,18 @@ pub struct BlockRootEmptyTxFirstRollupPrivateInputs { /// /// VkIndex: BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX pub fn execute(inputs: BlockRootEmptyTxFirstRollupPrivateInputs) -> BlockRollupPublicInputs { - validate_parity_root( - inputs.parity_root, - inputs.constants.vk_tree_root, - inputs.constants.prover_id, - ); - BlockRollupPublicInputsComposer::new_from_no_rollups( inputs.previous_archive, inputs.previous_state, inputs.constants, inputs.timestamp, ) - .with_new_l1_to_l2_messages( - inputs.parity_root.public_inputs, - inputs.new_l1_to_l2_message_subtree_root_sibling_path, + .with_message_bundle( + true, + inputs.previous_state.l1_to_l2_message_tree, + L1ToL2MessageSponge::new(), + inputs.message_bundle, + inputs.l1_to_l2_message_frontier_hint, ) .finish(inputs.new_archive_sibling_path) } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_first_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_first_rollup.nr index 62485020c117..665f3cb37c5b 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_first_rollup.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_first_rollup.nr @@ -1,43 +1,43 @@ use crate::{ - abis::{BlockRollupPublicInputs, ParityPublicInputs, TxRollupPublicInputs}, + abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge, TxRollupPublicInputs}, block_root::components::{ BlockRollupPublicInputsComposer, validate_l1_to_l2_tree_snapshot_in_constants, - validate_parity_root, validate_previous_rollups, + validate_previous_rollups, }, }; use types::{ abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot, constants::{ - ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, - PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PUBLIC_TX_BASE_ROLLUP_VK_INDEX, TX_MERGE_ROLLUP_VK_INDEX, + ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, PRIVATE_TX_BASE_ROLLUP_VK_INDEX, + PUBLIC_TX_BASE_ROLLUP_VK_INDEX, TX_MERGE_ROLLUP_VK_INDEX, }, - proof::proof_data::{RollupHonkProofData, UltraHonkProofData}, + proof::proof_data::RollupHonkProofData, }; global ALLOWED_PREVIOUS_VK_INDICES: [u32; 3] = [TX_MERGE_ROLLUP_VK_INDEX, PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PUBLIC_TX_BASE_ROLLUP_VK_INDEX]; pub struct BlockRootFirstRollupPrivateInputs { - pub(crate) parity_root: UltraHonkProofData, pub(crate) previous_rollups: [RollupHonkProofData; 2], - // Hinted value to insert the new l1-to-l2 message subtree to. + // L1-to-L2 message bundle inserted by this block. + pub(crate) message_bundle: L1ToL2MessageBundle, + // Hinted value the bundle is appended to. // This will be set to the `start_state` in the public inputs and validated in the checkpoint root circuit to // ensure it matches the l1-to-l2 tree snapshot in the header of the last block from the previous checkpoint. pub(crate) previous_l1_to_l2: AppendOnlyTreeSnapshot, - // Hint for inserting the new l1-to-l2 message subtree. - pub(crate) new_l1_to_l2_message_subtree_root_sibling_path: [Field; L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH], + // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against `previous_l1_to_l2`). + pub(crate) l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT], // Hint for inserting the new block hash to the last archive. pub(crate) new_archive_sibling_path: [Field; ARCHIVE_HEIGHT], } /// The Block Root First Rollup circuit finalizes the first block of a checkpoint. -/// It processes L1-to-L2 messages and creates the block header. +/// It inserts the block's L1-to-L2 message bundle and creates the block header. /// This variant is used for the first block with multiple transactions. /// /// This circuit: -/// - Verifies the parity root proof containing L1-to-L2 messages for the checkpoint /// - Verifies the proofs from two child tx rollups (Tx Base or Tx Merge circuits) -/// - Inserts the L1-to-L2 message subtree into the L1-to-L2 message tree +/// - Appends the block's L1-to-L2 message bundle to the L1-to-L2 message tree and absorbs it into the message sponge /// - Validates that the two child rollups are consecutive (end state of left matches start state of right) /// - Computes the block header hash and inserts it into the archive tree /// @@ -48,17 +48,16 @@ pub struct BlockRootFirstRollupPrivateInputs { pub fn execute(inputs: BlockRootFirstRollupPrivateInputs) -> BlockRollupPublicInputs { let previous_rollups = inputs.previous_rollups.map(|rollup| rollup.public_inputs); let mut composer = BlockRollupPublicInputsComposer::new_from_two_rollups(previous_rollups); - let new_l1_to_l2 = composer.update_l1_to_l2_tree_snapshots( - inputs.parity_root.public_inputs, - inputs.previous_l1_to_l2, - inputs.new_l1_to_l2_message_subtree_root_sibling_path, - ); - - validate_parity_root( - inputs.parity_root, - inputs.previous_rollups[0].public_inputs.constants.vk_tree_root, - inputs.previous_rollups[0].public_inputs.constants.prover_id, - ); + // The leftmost block of a checkpoint starts the message sponge from empty. + let new_l1_to_l2 = composer + .with_message_bundle( + true, + inputs.previous_l1_to_l2, + L1ToL2MessageSponge::new(), + inputs.message_bundle, + inputs.l1_to_l2_message_frontier_hint, + ) + .get_new_l1_to_l2(); validate_previous_rollups(inputs.previous_rollups, ALLOWED_PREVIOUS_VK_INDICES); diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_msgs_only_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_msgs_only_rollup.nr new file mode 100644 index 000000000000..becd18212ba4 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_msgs_only_rollup.nr @@ -0,0 +1,81 @@ +use crate::{ + abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge}, + block_root::components::BlockRollupPublicInputsComposer, +}; +use types::{ + abis::{ + append_only_tree_snapshot::AppendOnlyTreeSnapshot, + checkpoint_constant_data::CheckpointConstantData, state_reference::StateReference, + }, + blob_data::SpongeBlob, + constants::{ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT}, +}; + +pub struct BlockRootMsgsOnlyRollupPrivateInputs { + pub(crate) previous_archive: AppendOnlyTreeSnapshot, + pub(crate) previous_state: StateReference, + // The previous block is in the same checkpoint as this block, but this block has no txs, so there are no tx + // constants to carry them. The checkpoint constants are given as a free value here and pinned by the checkpoint + // root's previous-header check via the merge continuity of the states below. + pub(crate) constants: CheckpointConstantData, + // The timestamp of this block. It's given as a free value here, but will be checked against the previous block's + // timestamp in the block merge or checkpoint root. + pub(crate) timestamp: u64, + // Sponge blob inherited from the previous block. Checked against the previous block's `end_sponge_blob` in the + // block merge or checkpoint root circuit. + pub(crate) start_sponge_blob: SpongeBlob, + // Message sponge inherited from the previous block. Checked against the previous block's `end_msg_sponge` in the + // block merge or checkpoint root circuit. + pub(crate) start_msg_sponge: L1ToL2MessageSponge, + + // L1-to-L2 message bundle inserted by this block. + pub(crate) message_bundle: L1ToL2MessageBundle, + // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against `previous_state`). + pub(crate) l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT], + // Hint for inserting the new block hash to the last archive. + pub(crate) new_archive_sibling_path: [Field; ARCHIVE_HEIGHT], +} + +/// The Block Root Msgs Only Rollup circuit creates a non-first, transaction-less block that inserts an L1-to-L2 message +/// bundle. It lets a proposer keep draining the Inbox into a checkpoint when the tx pool is empty. +/// +/// Unlike the first-empty variant, this block sits in the middle of a checkpoint: it inherits the sponge blob and +/// message sponge from the previous block (rather than starting them from empty) and sets `is_first_block = false`. It +/// is deliberately unable to be the leftmost block of a checkpoint: the checkpoint root asserts the leftmost rollup's +/// `is_first_block` is true, so a checkpoint made only of this variant cannot prove. +/// +/// This circuit: +/// - Requires the bundle to be non-empty (`num_msgs > 0`); an empty non-first block carries no reason to exist and +/// would otherwise be a provable filler block +/// - Appends the block's L1-to-L2 message bundle to the L1-to-L2 message tree and absorbs it into the message sponge +/// - Threads the (non-empty) start sponge blob through unchanged, since there are no tx effects +/// - Computes the block header hash and inserts it into the archive tree +/// +/// The output feeds into a Block Merge circuit if more blocks need to be combined, or directly into a Checkpoint Root +/// circuit. +/// +/// VkIndex: BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX +pub fn execute(inputs: BlockRootMsgsOnlyRollupPrivateInputs) -> BlockRollupPublicInputs { + // A message-only block exists solely to insert L1-to-L2 messages, so it must carry at least one real message. This + // prevents a provable, fully-empty non-first filler block. + assert( + inputs.message_bundle.num_real_msgs != 0, + "A message-only block must insert at least one L1-to-L2 message", + ); + + BlockRollupPublicInputsComposer::new_from_no_rollups_with_start_sponge_blob( + inputs.previous_archive, + inputs.previous_state, + inputs.constants, + inputs.timestamp, + inputs.start_sponge_blob, + ) + .with_message_bundle( + false, + inputs.previous_state.l1_to_l2_message_tree, + inputs.start_msg_sponge, + inputs.message_bundle, + inputs.l1_to_l2_message_frontier_hint, + ) + .finish(inputs.new_archive_sibling_path) +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_rollup.nr index 4f971634aec0..b0a3119e00a1 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_rollup.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_rollup.nr @@ -1,11 +1,15 @@ use crate::{ - abis::{BlockRollupPublicInputs, TxRollupPublicInputs}, - block_root::components::{BlockRollupPublicInputsComposer, validate_previous_rollups}, + abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge, TxRollupPublicInputs}, + block_root::components::{ + BlockRollupPublicInputsComposer, validate_l1_to_l2_tree_snapshot_in_constants, + validate_previous_rollups, + }, }; use types::{ + abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot, constants::{ - ARCHIVE_HEIGHT, PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PUBLIC_TX_BASE_ROLLUP_VK_INDEX, - TX_MERGE_ROLLUP_VK_INDEX, + ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, PRIVATE_TX_BASE_ROLLUP_VK_INDEX, + PUBLIC_TX_BASE_ROLLUP_VK_INDEX, TX_MERGE_ROLLUP_VK_INDEX, }, proof::proof_data::RollupHonkProofData, }; @@ -15,16 +19,29 @@ global ALLOWED_PREVIOUS_VK_INDICES: [u32; 3] = pub struct BlockRootRollupPrivateInputs { pub(crate) previous_rollups: [RollupHonkProofData; 2], + // L1-to-L2 message bundle inserted by this block. + pub(crate) message_bundle: L1ToL2MessageBundle, + // The l1-to-l2 tree snapshot this block builds on (the previous block's post-insertion snapshot). It is a witnessed + // value, pinned by block-merge continuity (`right.start_state == left.end_state`) to the previous block's end + // state; since the checkpoint root forces the leftmost block to be a first-block variant, every non-first block + // has a left neighbour that pins it. + pub(crate) previous_l1_to_l2: AppendOnlyTreeSnapshot, + // Message sponge inherited from the previous block. Checked against the previous block's `end_msg_sponge` in the + // block merge or checkpoint root circuit. + pub(crate) start_msg_sponge: L1ToL2MessageSponge, + // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against `previous_l1_to_l2`). + pub(crate) l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT], // Hint for inserting the new block hash to the last archive. pub(crate) new_archive_sibling_path: [Field; ARCHIVE_HEIGHT], } /// The Block Root Rollup circuit finalizes a block by combining two transaction rollup proofs. -/// It creates the block header and does not process L1-to-L2 messages. +/// It inserts the block's L1-to-L2 message bundle and creates the block header. /// This variant is used for non-first blocks with multiple transactions. /// /// This circuit: /// - Verifies the proofs from two child tx rollups (Tx Base or Tx Merge circuits) +/// - Appends the block's L1-to-L2 message bundle to the L1-to-L2 message tree and absorbs it into the message sponge /// - Validates that the two child rollups are consecutive (end state of left matches start state of right) /// - Computes the block header hash and inserts it into the archive tree /// @@ -34,10 +51,29 @@ pub struct BlockRootRollupPrivateInputs { /// /// VkIndex: BLOCK_ROOT_ROLLUP_VK_INDEX pub fn execute(inputs: BlockRootRollupPrivateInputs) -> BlockRollupPublicInputs { + let previous_rollups = inputs.previous_rollups.map(|rollup| rollup.public_inputs); + // Non-first blocks build on a witnessed start snapshot (pinned by block-merge continuity to the previous block's + // end state) rather than the constants value, so this block can append its own bundle and still assert the tx + // constants carry the post-bundle snapshot. + let mut composer = BlockRollupPublicInputsComposer::new_from_two_rollups(previous_rollups); + let new_l1_to_l2 = composer + .with_message_bundle( + false, + inputs.previous_l1_to_l2, + inputs.start_msg_sponge, + inputs.message_bundle, + inputs.l1_to_l2_message_frontier_hint, + ) + .get_new_l1_to_l2(); + validate_previous_rollups(inputs.previous_rollups, ALLOWED_PREVIOUS_VK_INDICES); - let previous_rollups = inputs.previous_rollups.map(|rollup| rollup.public_inputs); - BlockRollupPublicInputsComposer::new_from_two_rollups(previous_rollups).finish( - inputs.new_archive_sibling_path, - ) + // The tx constants pin the l1-to-l2 snapshot the AVM validates message reads against; asserting it equals this + // block's post-bundle root lets this block's txs read the messages this block inserts (same-block consumption). + validate_l1_to_l2_tree_snapshot_in_constants( + inputs.previous_rollups[0].public_inputs.constants, + new_l1_to_l2, + ); + + composer.finish(inputs.new_archive_sibling_path) } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_single_tx_first_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_single_tx_first_rollup.nr index 5f9fb37a2597..ff318e4b2eb5 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_single_tx_first_rollup.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_single_tx_first_rollup.nr @@ -1,17 +1,17 @@ use crate::{ - abis::{BlockRollupPublicInputs, ParityPublicInputs, TxRollupPublicInputs}, + abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge, TxRollupPublicInputs}, block_root::components::{ BlockRollupPublicInputsComposer, validate_l1_to_l2_tree_snapshot_in_constants, - validate_parity_root, validate_previous_rollups, + validate_previous_rollups, }, }; use types::{ abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot, constants::{ - ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, - PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PUBLIC_TX_BASE_ROLLUP_VK_INDEX, + ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, PRIVATE_TX_BASE_ROLLUP_VK_INDEX, + PUBLIC_TX_BASE_ROLLUP_VK_INDEX, }, - proof::proof_data::{RollupHonkProofData, UltraHonkProofData}, + proof::proof_data::RollupHonkProofData, }; // TX_MERGE_ROLLUP_VK_INDEX is not allowed if there is only one previous rollup. @@ -19,26 +19,26 @@ global ALLOWED_PREVIOUS_VK_INDICES: [u32; 2] = [PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PUBLIC_TX_BASE_ROLLUP_VK_INDEX]; pub struct BlockRootSingleTxFirstRollupPrivateInputs { - pub(crate) parity_root: UltraHonkProofData, pub(crate) previous_rollup: RollupHonkProofData, - // Hinted value to insert the new l1-to-l2 message subtree to. + // L1-to-L2 message bundle inserted by this block. + pub(crate) message_bundle: L1ToL2MessageBundle, + // Hinted value the bundle is appended to. // This will be set to the `start_state` in the public inputs and validated in the checkpoint root circuit to // ensure it matches the l1-to-l2 tree snapshot in the header of the last block from the previous checkpoint. pub(crate) previous_l1_to_l2: AppendOnlyTreeSnapshot, - // Hint for inserting the new l1 to l2 message subtree. - pub(crate) new_l1_to_l2_message_subtree_root_sibling_path: [Field; L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH], + // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against `previous_l1_to_l2`). + pub(crate) l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT], // Hint for inserting the new block hash to the last archive. pub(crate) new_archive_sibling_path: [Field; ARCHIVE_HEIGHT], } /// The Block Root Single Tx First Rollup circuit finalizes the first block of a checkpoint. -/// It processes L1-to-L2 messages and creates the block header. +/// It inserts the block's L1-to-L2 message bundle and creates the block header. /// This variant is used for the first block with only one transaction. /// /// This circuit: -/// - Verifies the parity root proof containing L1-to-L2 messages for the checkpoint /// - Verifies the proof from a single tx rollup (Private Tx Base or Public Tx Base circuit) -/// - Inserts the L1-to-L2 message subtree into the L1-to-L2 message tree +/// - Appends the block's L1-to-L2 message bundle to the L1-to-L2 message tree and absorbs it into the message sponge /// - Computes the block header hash and inserts it into the archive tree /// /// The output feeds into a Block Merge circuit if more blocks need to be combined, @@ -49,17 +49,16 @@ pub fn execute(inputs: BlockRootSingleTxFirstRollupPrivateInputs) -> BlockRollup let mut composer = BlockRollupPublicInputsComposer::new_from_single_rollup( inputs.previous_rollup.public_inputs, ); - let new_l1_to_l2 = composer.update_l1_to_l2_tree_snapshots( - inputs.parity_root.public_inputs, - inputs.previous_l1_to_l2, - inputs.new_l1_to_l2_message_subtree_root_sibling_path, - ); - - validate_parity_root( - inputs.parity_root, - inputs.previous_rollup.public_inputs.constants.vk_tree_root, - inputs.previous_rollup.public_inputs.constants.prover_id, - ); + // The leftmost block of a checkpoint starts the message sponge from empty. + let new_l1_to_l2 = composer + .with_message_bundle( + true, + inputs.previous_l1_to_l2, + L1ToL2MessageSponge::new(), + inputs.message_bundle, + inputs.l1_to_l2_message_frontier_hint, + ) + .get_new_l1_to_l2(); validate_previous_rollups([inputs.previous_rollup], ALLOWED_PREVIOUS_VK_INDICES); diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_single_tx_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_single_tx_rollup.nr index 00c7fd012803..3c3cacbdaea8 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_single_tx_rollup.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/block_root_single_tx_rollup.nr @@ -1,9 +1,16 @@ use crate::{ - abis::{BlockRollupPublicInputs, TxRollupPublicInputs}, - block_root::components::{BlockRollupPublicInputsComposer, validate_previous_rollups}, + abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge, TxRollupPublicInputs}, + block_root::components::{ + BlockRollupPublicInputsComposer, validate_l1_to_l2_tree_snapshot_in_constants, + validate_previous_rollups, + }, }; use types::{ - constants::{ARCHIVE_HEIGHT, PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PUBLIC_TX_BASE_ROLLUP_VK_INDEX}, + abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot, + constants::{ + ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, PRIVATE_TX_BASE_ROLLUP_VK_INDEX, + PUBLIC_TX_BASE_ROLLUP_VK_INDEX, + }, proof::proof_data::RollupHonkProofData, }; @@ -13,16 +20,29 @@ global ALLOWED_PREVIOUS_VK_INDICES: [u32; 2] = pub struct BlockRootSingleTxRollupPrivateInputs { pub(crate) previous_rollup: RollupHonkProofData, + // L1-to-L2 message bundle inserted by this block. + pub(crate) message_bundle: L1ToL2MessageBundle, + // The l1-to-l2 tree snapshot this block builds on (the previous block's post-insertion snapshot). It is a witnessed + // value, pinned by block-merge continuity (`right.start_state == left.end_state`) to the previous block's end + // state; since the checkpoint root forces the leftmost block to be a first-block variant, every non-first block + // has a left neighbour that pins it. + pub(crate) previous_l1_to_l2: AppendOnlyTreeSnapshot, + // Message sponge inherited from the previous block. Checked against the previous block's `end_msg_sponge` in the + // block merge or checkpoint root circuit. + pub(crate) start_msg_sponge: L1ToL2MessageSponge, + // Frontier hint for appending the bundle to the l1-to-l2 message tree (validated against `previous_l1_to_l2`). + pub(crate) l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT], // Hint for inserting the new block hash to the last archive. pub(crate) new_archive_sibling_path: [Field; ARCHIVE_HEIGHT], } /// The Block Root Single Tx Rollup circuit finalizes a block containing exactly one transaction. -/// It creates the block header and does not process L1-to-L2 messages. +/// It inserts the block's L1-to-L2 message bundle and creates the block header. /// This variant is used for non-first blocks with only one transaction. /// /// This circuit: /// - Verifies the proof from a single tx rollup (Private Tx Base or Public Tx Base circuit) +/// - Appends the block's L1-to-L2 message bundle to the L1-to-L2 message tree and absorbs it into the message sponge /// - Computes the block header hash and inserts it into the archive tree /// /// The output feeds into a Block Merge circuit if more blocks need to be combined, @@ -31,8 +51,30 @@ pub struct BlockRootSingleTxRollupPrivateInputs { /// /// VkIndex: BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX pub fn execute(inputs: BlockRootSingleTxRollupPrivateInputs) -> BlockRollupPublicInputs { + // Non-first blocks build on a witnessed start snapshot (pinned by block-merge continuity to the previous block's + // end state) rather than the constants value, so this block can append its own bundle and still assert the tx + // constants carry the post-bundle snapshot. + let mut composer = BlockRollupPublicInputsComposer::new_from_single_rollup( + inputs.previous_rollup.public_inputs, + ); + let new_l1_to_l2 = composer + .with_message_bundle( + false, + inputs.previous_l1_to_l2, + inputs.start_msg_sponge, + inputs.message_bundle, + inputs.l1_to_l2_message_frontier_hint, + ) + .get_new_l1_to_l2(); + validate_previous_rollups([inputs.previous_rollup], ALLOWED_PREVIOUS_VK_INDICES); - BlockRollupPublicInputsComposer::new_from_single_rollup(inputs.previous_rollup.public_inputs) - .finish(inputs.new_archive_sibling_path) + // The tx constants pin the l1-to-l2 snapshot the AVM validates message reads against; asserting it equals this + // block's post-bundle root lets this block's txs read the messages this block inserts (same-block consumption). + validate_l1_to_l2_tree_snapshot_in_constants( + inputs.previous_rollup.public_inputs.constants, + new_l1_to_l2, + ); + + composer.finish(inputs.new_archive_sibling_path) } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_rollup_public_inputs_composer.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_rollup_public_inputs_composer.nr index 2d11d861b95e..7a3db775dd81 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_rollup_public_inputs_composer.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_rollup_public_inputs_composer.nr @@ -1,5 +1,5 @@ use crate::{ - abis::{BlockRollupPublicInputs, ParityPublicInputs, TxRollupPublicInputs}, + abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge, TxRollupPublicInputs}, tx_merge::merge_tx_rollups, }; use types::{ @@ -9,12 +9,10 @@ use types::{ partial_state_reference::PartialStateReference, state_reference::StateReference, }, blob_data::SpongeBlob, - constants::{ - ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, - L1_TO_L2_MSG_TREE_HEIGHT, - }, + constants::{ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT}, merkle_tree::append_only_tree, traits::Hash, + utils::arrays::assert_trailing_zeros, }; pub struct BlockRollupPublicInputsComposer { @@ -31,9 +29,15 @@ pub struct BlockRollupPublicInputsComposer { accumulated_fees: Field, accumulated_mana_used: Field, num_txs: u16, - // The followings are set by calling `with_new_l1_to_l2_messages` explicitly. - in_hash: Field, + // The followings are set by calling `with_message_bundle` explicitly. + is_first_block: bool, + start_msg_sponge: L1ToL2MessageSponge, + end_msg_sponge: L1ToL2MessageSponge, new_l1_to_l2: AppendOnlyTreeSnapshot, + // Set by `with_message_bundle` and asserted by `finish`. Without it, a variant that forgot to apply its bundle + // would emit `previous_l1_to_l2 == new_l1_to_l2 == constants.l1_to_l2_tree_snapshot`: a silent no-op append that + // still satisfies the snapshot check against the constants. + bundle_applied: bool, } impl BlockRollupPublicInputsComposer { @@ -43,8 +47,27 @@ impl BlockRollupPublicInputsComposer { constants: CheckpointConstantData, timestamp: u64, ) -> Self { - let empty_sponge_blob = SpongeBlob::init(); + // The first block of a checkpoint starts from an empty sponge blob. + Self::new_from_no_rollups_with_start_sponge_blob( + previous_archive, + previous_state, + constants, + timestamp, + SpongeBlob::init(), + ) + } + /// Same as `new_from_no_rollups` but for a non-first block, which inherits a (non-empty) sponge blob from the + /// previous block instead of starting from empty. The `start_sponge_blob` is threaded unchanged as the end sponge + /// blob (before this block's end data is absorbed in `finish`), since a block with no txs adds no tx effects. It is + /// pinned against the previous block's `end_sponge_blob` at the block merge or checkpoint root. + pub fn new_from_no_rollups_with_start_sponge_blob( + previous_archive: AppendOnlyTreeSnapshot, + previous_state: StateReference, + constants: CheckpointConstantData, + timestamp: u64, + start_sponge_blob: SpongeBlob, + ) -> Self { Self { constants, previous_archive, @@ -52,18 +75,20 @@ impl BlockRollupPublicInputsComposer { // The state remains the same since there are no tx effects in this block. start_tree_snapshots: previous_state.partial, end_tree_snapshots: previous_state.partial, - // Since it's the first block in a checkpoint, the start sponge blob is empty. - start_sponge_blob: empty_sponge_blob, - end_sponge_blob: empty_sponge_blob, + start_sponge_blob, + end_sponge_blob: start_sponge_blob, timestamp, // The followings are 0 since there are no tx effects in this block. out_hash: 0, accumulated_fees: 0, accumulated_mana_used: 0, num_txs: 0, - // The followings are updated by calling `with_new_l1_to_l2_messages` explicitly. - in_hash: 0, + // The followings are updated by calling `with_message_bundle` explicitly. + is_first_block: false, + start_msg_sponge: L1ToL2MessageSponge::new(), + end_msg_sponge: L1ToL2MessageSponge::new(), new_l1_to_l2: previous_state.l1_to_l2_message_tree, + bundle_applied: false, } } @@ -96,10 +121,13 @@ impl BlockRollupPublicInputsComposer { accumulated_fees: rollup.accumulated_fees, accumulated_mana_used: rollup.accumulated_mana_used, num_txs: rollup.num_txs, - // The followings are updated by calling `update_l1_to_l2_tree_snapshots` explicitly. + // The followings are updated by calling `with_message_bundle` explicitly. previous_l1_to_l2: rollup.constants.l1_to_l2_tree_snapshot, - in_hash: 0, + is_first_block: false, + start_msg_sponge: L1ToL2MessageSponge::new(), + end_msg_sponge: L1ToL2MessageSponge::new(), new_l1_to_l2: rollup.constants.l1_to_l2_tree_snapshot, + bundle_applied: false, } } @@ -108,40 +136,77 @@ impl BlockRollupPublicInputsComposer { Self::new_from_single_rollup(merged_rollup) } - pub fn with_new_l1_to_l2_messages( + /// Appends this block's L1-to-L2 message bundle to the tree and absorbs its real messages into the message sponge. + /// + /// `previous_l1_to_l2` is the tree snapshot this block builds on: for the first block it is the pre-insertion + /// snapshot (hinted, and later checked against the previous checkpoint), for subsequent blocks it is a witnessed + /// snapshot pinned by block-merge continuity to the previous block's end state. Either way, the caller asserts the + /// tx constants carry the resulting post-bundle snapshot. `start_msg_sponge` is the sponge inherited from the + /// previous block (empty for the first block). + /// + /// The tree append and the sponge absorb use different counts transitionally (see `L1ToL2MessageBundle`): the tree + /// inserts `bundle.num_msgs` leaves (a full padded subtree for a message-bearing block), while the sponge absorbs + /// only `bundle.num_real_msgs` real leaves so it matches the checkpoint's variable-size `InboxParity` proof. The + /// padding lanes past `num_real_msgs` must be zero. + pub fn with_message_bundle( &mut self, - parity: ParityPublicInputs, - subtree_root_sibling_path: [Field; L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH], + is_first_block: bool, + previous_l1_to_l2: AppendOnlyTreeSnapshot, + start_msg_sponge: L1ToL2MessageSponge, + bundle: L1ToL2MessageBundle, + frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT], ) -> Self { - self.in_hash = parity.sha_root; + self.is_first_block = is_first_block; + self.previous_l1_to_l2 = previous_l1_to_l2; + self.bundle_applied = true; + + // Real messages occupy the leading lanes; everything past `num_real_msgs` is zero padding, including the + // padding that fills out the tree's fixed subtree insert. + assert_trailing_zeros(bundle.messages, bundle.num_real_msgs); + + // The sponge absorbs a prefix of what the tree inserts, so the real count can never exceed the insert count. + assert(bundle.num_real_msgs <= bundle.num_msgs, "more real messages than tree leaves"); - // Insert subtree into the l1-to-l2 message tree. - self.new_l1_to_l2 = append_only_tree::insert_subtree_root_to_snapshot::( - self.previous_l1_to_l2, - subtree_root_sibling_path, - parity.converted_root, + // NOTE: `num_msgs` (the tree-insert count) is not otherwise pinned in-circuit — nothing here forces it to the + // padded subtree size. On the honest path the orchestrator sets it to `MAX_L1_TO_L2_MSGS_PER_BLOCK` for the + // first block and 0 otherwise, and the resulting `new_l1_to_l2` snapshot is what binds it (first-block variants + // check it against the tx-constants snapshot, ultimately the L1 pending-chain header hash). Like the + // unconstrained `in_hash`, a fully trustless binding is deferred to the Fast Inbox flip. + + // Append the bundle to the l1-to-l2 message tree at its current (arbitrary) next-available index. + self.new_l1_to_l2 = append_only_tree::append_leaves_to_snapshot::( + previous_l1_to_l2, + bundle.messages, + bundle.num_msgs, + frontier_hint, ); + // Absorb the real leaves into the message sponge, threading it from the previous block. + self.start_msg_sponge = start_msg_sponge; + let mut end_msg_sponge = start_msg_sponge; + end_msg_sponge.absorb(bundle.messages, bundle.num_real_msgs); + self.end_msg_sponge = end_msg_sponge; + *self } - pub fn update_l1_to_l2_tree_snapshots( - &mut self, - parity: ParityPublicInputs, - previous_l1_to_l2: AppendOnlyTreeSnapshot, - subtree_root_sibling_path: [Field; L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH], - ) -> AppendOnlyTreeSnapshot { - // Update the previous l1-to-l2 tree snapshot to build the new snapshot with. - self.previous_l1_to_l2 = previous_l1_to_l2; - - // Update the new l1-to-l2 tree snapshot and return it. - self.with_new_l1_to_l2_messages(parity, subtree_root_sibling_path).new_l1_to_l2 + /// The l1-to-l2 tree snapshot after appending this block's bundle. Tx-carrying variants (first and non-first) + /// check this against the snapshot in the tx constants (consumed by the AVM to read new messages). + pub fn get_new_l1_to_l2(self) -> AppendOnlyTreeSnapshot { + self.new_l1_to_l2 } pub fn finish( self, new_archive_sibling_path: [Field; ARCHIVE_HEIGHT], ) -> BlockRollupPublicInputs { + // Every block transitions the l1-to-l2 message tree, even when its bundle is empty, so the append is not + // optional: skipping it would leave the start and end snapshots trivially equal. + assert( + self.bundle_applied, + "with_message_bundle must be called before finishing the block rollup", + ); + // Build the header of this block and then insert its hash to the archive tree. let (block_header, end_sponge_blob) = self.create_block_header_and_end_sponge_blob(); let block_header_hash = block_header.hash(); @@ -166,7 +231,9 @@ impl BlockRollupPublicInputsComposer { end_sponge_blob, timestamp: self.timestamp, block_headers_hash: block_header_hash, - in_hash: self.in_hash, + is_first_block: self.is_first_block, + start_msg_sponge: self.start_msg_sponge, + end_msg_sponge: self.end_msg_sponge, out_hash: self.out_hash, accumulated_fees: self.accumulated_fees, accumulated_mana_used: self.accumulated_mana_used, @@ -216,20 +283,17 @@ impl BlockRollupPublicInputsComposer { // Absorb data for this block into the end sponge blob. let mut block_end_sponge_blob = self.end_sponge_blob; - // `in_hash` is not 0 if and only if it's the first block in the checkpoint. - // Note: the `in_hash` of the first block in the checkpoint is asserted to be nonzero - // by the Checkpoint Root circuit. - // Note: the `in_hash` of subsequent blocks in the checkpoint is asserted to be 0 - // within `validate_consecutive_block_rollups.nr`, by asserting that the `in_hash` of all - // "right" rollups is `0`. - let is_first_block_in_checkpoint = self.in_hash != 0; + // The l1-to-l2 message tree root is absorbed only for the first block of a checkpoint (the value is shared by + // all blocks in the checkpoint). `is_first_block` is asserted true at the checkpoint root and false for every + // non-first ("right") rollup in `validate_consecutive_block_rollups.nr`, so it can only be true for the first + // block. This replaces the former `in_hash != 0` derivation. block_end_sponge_blob.absorb_block_end_data( global_variables, last_archive, state, self.num_txs, self.accumulated_mana_used, - is_first_block_in_checkpoint, + self.is_first_block, ); // Duplicate the `block_end_sponge_blob` so that we can squeeze it. diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_root_rollup_inputs_validator.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_root_rollup_inputs_validator.nr index 53599b0017c4..35abb99345e0 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_root_rollup_inputs_validator.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/block_root_rollup_inputs_validator.nr @@ -1,13 +1,12 @@ use crate::{ - abis::{ParityPublicInputs, TxRollupPublicInputs}, + abis::TxRollupPublicInputs, tx_merge::utils::validate_consecutive_tx_rollups::validate_consecutive_tx_rollups, }; use types::{ abis::{ append_only_tree_snapshot::AppendOnlyTreeSnapshot, block_constant_data::BlockConstantData, }, - constants::PARITY_ROOT_VK_INDEX, - proof::proof_data::{RollupHonkProofData, UltraHonkProofData}, + proof::proof_data::RollupHonkProofData, }; pub fn validate_previous_rollups( @@ -51,11 +50,11 @@ pub fn validate_previous_rollups, - vk_tree_root: Field, - prover_id: Field, -) { - if !::std::runtime::is_unconstrained() { - data.verify_proof(); - } - - assert_eq(data.vk_data.leaf_index, PARITY_ROOT_VK_INDEX, "Incorrect vk index for parity root"); - - // Check that the `vk_tree_root` in the public inputs matches the one in the rollup's constants, as it was used - // to verify the vk of the base parity proofs. - assert_eq( - data.public_inputs.vk_tree_root, - vk_tree_root, - "The vk tree root of the parity root does not match the rollup's vk tree root", - ); - - // Check that the `prover_id` in the public inputs matches the one in the rollup's constants, preventing sybil - // attacks where the same prover submits a parity root proof under different identities. - assert_eq( - data.public_inputs.prover_id, - prover_id, - "The prover id of the parity root does not match the rollup's prover id", - ); - - data.vk_data.validate_in_vk_tree(vk_tree_root); -} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/mod.nr index 205550e6b6fe..62ea8f9b152d 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/components/mod.nr @@ -3,5 +3,5 @@ mod block_rollup_public_inputs_composer; pub use block_rollup_public_inputs_composer::BlockRollupPublicInputsComposer; pub use block_root_rollup_inputs_validator::{ - validate_l1_to_l2_tree_snapshot_in_constants, validate_parity_root, validate_previous_rollups, + validate_l1_to_l2_tree_snapshot_in_constants, validate_previous_rollups, }; diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/mod.nr index 6443dd58f68a..5a72b9bd3da2 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/mod.nr @@ -4,12 +4,14 @@ pub mod block_root_single_tx_first_rollup; pub mod block_root_empty_tx_first_rollup; pub mod block_root_rollup; pub mod block_root_single_tx_rollup; +pub mod block_root_msgs_only_rollup; mod tests; // Re-exports pub use crate::abis::BlockRollupPublicInputs; pub use block_root_empty_tx_first_rollup::BlockRootEmptyTxFirstRollupPrivateInputs; pub use block_root_first_rollup::BlockRootFirstRollupPrivateInputs; +pub use block_root_msgs_only_rollup::BlockRootMsgsOnlyRollupPrivateInputs; pub use block_root_rollup::BlockRootRollupPrivateInputs; pub use block_root_single_tx_first_rollup::BlockRootSingleTxFirstRollupPrivateInputs; pub use block_root_single_tx_rollup::BlockRootSingleTxRollupPrivateInputs; diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/child_proof_vk_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/child_proof_vk_tests.nr index fda5d9f605f0..3c72cab9126c 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/child_proof_vk_tests.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/child_proof_vk_tests.nr @@ -1,8 +1,8 @@ use super::TestBuilder; use protocol_test_utils::fixtures::vk_tree::{update_vk_hash, VK_MERKLE_TREE}; use types::constants::{ - BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_ROLLUP_VK_INDEX, PARITY_BASE_VK_INDEX, - PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PUBLIC_TX_BASE_ROLLUP_VK_INDEX, + BLOCK_ROOT_ROLLUP_VK_INDEX, INBOX_PARITY_64_VK_INDEX, PRIVATE_TX_BASE_ROLLUP_VK_INDEX, + PUBLIC_TX_BASE_ROLLUP_VK_INDEX, }; #[test(should_fail_with = "Vk index not in allowed list")] @@ -27,7 +27,7 @@ fn disallowed_right_rollup_vk_index__first_block() { fn disallowed_rollup_vk_index__first_single_tx_block() { let mut builder = TestBuilder::default(true, true); - builder.left_rollup_vk_index = PARITY_BASE_VK_INDEX; + builder.left_rollup_vk_index = INBOX_PARITY_64_VK_INDEX; builder.execute_and_fail(); } @@ -73,7 +73,6 @@ fn left_rollup_vk_not_in_vk_tree__first_block() { let mut new_vk_tree = VK_MERKLE_TREE; update_vk_hash(&mut new_vk_tree, builder.left_rollup_vk_index, 999); - builder.parity_root.vk_tree_root = new_vk_tree.get_root(); builder.left_rollup.constants.vk_tree_root = new_vk_tree.get_root(); builder.execute_and_fail(); @@ -93,7 +92,6 @@ fn right_rollup_vk_not_in_vk_tree__first_block() { let mut new_vk_tree = VK_MERKLE_TREE; update_vk_hash(&mut new_vk_tree, builder.right_rollup_vk_index, 999); - builder.parity_root.vk_tree_root = new_vk_tree.get_root(); builder.left_rollup.constants.vk_tree_root = new_vk_tree.get_root(); builder.execute_and_fail(); @@ -107,7 +105,6 @@ fn left_rollup_vk_not_in_vk_tree__first_single_tx_block() { let mut new_vk_tree = VK_MERKLE_TREE; update_vk_hash(&mut new_vk_tree, builder.left_rollup_vk_index, 999); - builder.parity_root.vk_tree_root = new_vk_tree.get_root(); builder.left_rollup.constants.vk_tree_root = new_vk_tree.get_root(); builder.execute_and_fail(); @@ -127,7 +124,6 @@ fn left_rollup_vk_not_in_vk_tree__non_first_block() { let mut new_vk_tree = VK_MERKLE_TREE; update_vk_hash(&mut new_vk_tree, builder.left_rollup_vk_index, 999); - builder.parity_root.vk_tree_root = new_vk_tree.get_root(); builder.left_rollup.constants.vk_tree_root = new_vk_tree.get_root(); builder.execute_and_fail(); @@ -147,7 +143,6 @@ fn right_rollup_vk_not_in_vk_tree__non_first_block() { let mut new_vk_tree = VK_MERKLE_TREE; update_vk_hash(&mut new_vk_tree, builder.right_rollup_vk_index, 999); - builder.parity_root.vk_tree_root = new_vk_tree.get_root(); builder.left_rollup.constants.vk_tree_root = new_vk_tree.get_root(); builder.execute_and_fail(); @@ -161,82 +156,7 @@ fn left_rollup_vk_not_in_vk_tree__non_first_single_tx_block() { let mut new_vk_tree = VK_MERKLE_TREE; update_vk_hash(&mut new_vk_tree, builder.left_rollup_vk_index, 999); - builder.parity_root.vk_tree_root = new_vk_tree.get_root(); builder.left_rollup.constants.vk_tree_root = new_vk_tree.get_root(); builder.execute_and_fail(); } - -// --- Parity root --- - -#[test(should_fail_with = "Incorrect vk index for parity root")] -fn incorrect_parity_root_vk_index__first_block() { - let mut builder = TestBuilder::default(true, false); - - // Change the vk index of the parity root to something else. - builder.parity_root_vk_index = BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX; - - builder.execute_and_fail(); -} - -#[test(should_fail_with = "Incorrect vk index for parity root")] -fn incorrect_parity_root_vk_index__first_single_tx_block() { - let mut builder = TestBuilder::default(true, true); - - // Change the vk index of the parity root to something else. - builder.parity_root_vk_index = PARITY_BASE_VK_INDEX; - - builder.execute_and_fail(); -} - -#[test(should_fail_with = "Incorrect vk index for parity root")] -fn incorrect_parity_root_vk_index__first_empty_block() { - let mut builder = TestBuilder::new_empty(); - - // Change the vk index of the parity root to something else. - builder.parity_root_vk_index = PARITY_BASE_VK_INDEX; - - builder.execute_and_fail(); -} - -#[test(should_fail_with = "Membership check failed: vk hash not found in vk tree")] -fn parity_root_vk_not_in_vk_tree__first_block() { - let mut builder = TestBuilder::default(true, false); - - // Update the vk hash so that the old vk hash in the proof data is no longer in the vk tree. - let mut new_vk_tree = VK_MERKLE_TREE; - update_vk_hash(&mut new_vk_tree, builder.parity_root_vk_index, 999); - - builder.parity_root.vk_tree_root = new_vk_tree.get_root(); - builder.left_rollup.constants.vk_tree_root = new_vk_tree.get_root(); - - builder.execute_and_fail(); -} - -#[test(should_fail_with = "Membership check failed: vk hash not found in vk tree")] -fn parity_root_vk_not_in_vk_tree__first_single_tx_block() { - let mut builder = TestBuilder::default(true, true); - - // Update the vk hash so that the old vk hash in the proof data is no longer in the vk tree. - let mut new_vk_tree = VK_MERKLE_TREE; - update_vk_hash(&mut new_vk_tree, builder.parity_root_vk_index, 999); - - builder.parity_root.vk_tree_root = new_vk_tree.get_root(); - builder.left_rollup.constants.vk_tree_root = new_vk_tree.get_root(); - - builder.execute_and_fail(); -} - -#[test(should_fail_with = "Membership check failed: vk hash not found in vk tree")] -fn parity_root_vk_not_in_vk_tree__first_empty_block() { - let mut builder = TestBuilder::new_empty(); - - // Update the vk hash so that the old vk hash in the proof data is no longer in the vk tree. - let mut new_vk_tree = VK_MERKLE_TREE; - update_vk_hash(&mut new_vk_tree, builder.parity_root_vk_index, 999); - - builder.parity_root.vk_tree_root = new_vk_tree.get_root(); - builder.checkpoint_constants.vk_tree_root = new_vk_tree.get_root(); - - builder.execute_and_fail(); -} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/failures_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/failures_tests.nr index dd65d2ba8243..4338380796f5 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/failures_tests.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/failures_tests.nr @@ -161,32 +161,48 @@ fn incorrect_l1_to_l2_tree_next_available_leaf_index__first_single_tx_block() { builder.execute_and_fail(); } -#[test(should_fail_with = "The vk tree root of the parity root does not match the rollup's vk tree root")] -fn mismatched_vk_tree_root_from_parity__first_block() { - let mut builder = TestBuilder::default(true, false); +// Non-first blocks also insert their own bundle and must pin the post-bundle snapshot in their tx constants, so a +// non-first block whose constants snapshot differs from its computed post-bundle root must fail (same-block +// consumption). Both child rollups are tweaked together so the mismatch surfaces here rather than as unequal +// constants between the two tx rollups. +#[test(should_fail_with = "l1_to_l2 tree snapshot in constants does not match the computed value")] +fn incorrect_l1_to_l2_tree_root__non_first_block() { + let mut builder = TestBuilder::default(false, false); - // Tweak the vk tree root of the parity root. - builder.parity_root.vk_tree_root += 1; + // Tweak the root of the l1_to_l2_tree_snapshot in the rollups' constants. + builder.left_rollup.constants.l1_to_l2_tree_snapshot.root += 1; + builder.right_rollup.constants.l1_to_l2_tree_snapshot.root += 1; builder.execute_and_fail(); } -#[test(should_fail_with = "The vk tree root of the parity root does not match the rollup's vk tree root")] -fn mismatched_vk_tree_root_from_parity__first_single_tx_block() { - let mut builder = TestBuilder::default(true, true); +#[test(should_fail_with = "l1_to_l2 tree snapshot in constants does not match the computed value")] +fn incorrect_l1_to_l2_tree_next_available_leaf_index__non_first_block() { + let mut builder = TestBuilder::default(false, false); - // Tweak the vk tree root of the parity root. - builder.parity_root.vk_tree_root += 1; + // Tweak the next_available_leaf_index of the l1_to_l2_tree_snapshot in the rollups' constants. + builder.left_rollup.constants.l1_to_l2_tree_snapshot.next_available_leaf_index += 1; + builder.right_rollup.constants.l1_to_l2_tree_snapshot.next_available_leaf_index += 1; builder.execute_and_fail(); } -#[test(should_fail_with = "The vk tree root of the parity root does not match the rollup's vk tree root")] -fn mismatched_vk_tree_root_from_parity__first_empty_block() { - let mut builder = TestBuilder::new_empty(); +#[test(should_fail_with = "l1_to_l2 tree snapshot in constants does not match the computed value")] +fn incorrect_l1_to_l2_tree_root__non_first_single_tx_block() { + let mut builder = TestBuilder::default(false, true); - // Tweak the vk tree root of the parity root. - builder.parity_root.vk_tree_root += 1; + // Tweak the root of the l1_to_l2_tree_snapshot in the rollup's constants. + builder.left_rollup.constants.l1_to_l2_tree_snapshot.root += 1; + + builder.execute_and_fail(); +} + +#[test(should_fail_with = "l1_to_l2 tree snapshot in constants does not match the computed value")] +fn incorrect_l1_to_l2_tree_next_available_leaf_index__non_first_single_tx_block() { + let mut builder = TestBuilder::default(false, true); + + // Tweak the next_available_leaf_index of the l1_to_l2_tree_snapshot in the rollup's constants. + builder.left_rollup.constants.l1_to_l2_tree_snapshot.next_available_leaf_index += 1; builder.execute_and_fail(); } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/message_bundle_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/message_bundle_tests.nr new file mode 100644 index 000000000000..7c17032f3c45 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/message_bundle_tests.nr @@ -0,0 +1,54 @@ +use super::TestBuilder; +use types::constants::{PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PUBLIC_TX_BASE_ROLLUP_VK_INDEX}; + +global IS_FIRST_BLOCK_ROOT: bool = true; + +// A start index that is a right child at some levels and a left child at others, so the append has to merge the batch +// into a real frontier rather than drop an aligned subtree into an empty slot. +global NON_ALIGNED_START_INDEX: u32 = 5; + +fn builder_at_non_aligned_index(is_first_block_root: bool) -> TestBuilder { + TestBuilder::new_at_l1_to_l2_index( + PRIVATE_TX_BASE_ROLLUP_VK_INDEX, + 1, + PUBLIC_TX_BASE_ROLLUP_VK_INDEX, + 1, + is_first_block_root, + NON_ALIGNED_START_INDEX, + ) +} + +#[test] +fn first_block_appends_at_non_aligned_index() { + let builder = builder_at_non_aligned_index(IS_FIRST_BLOCK_ROOT); + let pi = builder.execute(); + builder.assert_expected_public_inputs(pi); +} + +#[test] +fn non_first_block_appends_at_non_aligned_index() { + let builder = builder_at_non_aligned_index(!IS_FIRST_BLOCK_ROOT); + let pi = builder.execute(); + builder.assert_expected_public_inputs(pi); +} + +#[test] +fn unpinned_frontier_hint_lane_is_ignored() { + // Index 5 is a left child at level 1, so the snapshot root cannot pin that hint lane. The append overwrites it + // with the batch's own node before anything reads it, so a wrong value there must not change the result. + let mut builder = builder_at_non_aligned_index(!IS_FIRST_BLOCK_ROOT); + builder.l1_to_l2_message_frontier_hint[1] += 1; + + let pi = builder.execute(); + builder.assert_expected_public_inputs(pi); +} + +#[test(should_fail_with = "Frontier hint does not match the snapshot root")] +fn corrupted_pinned_frontier_hint_lane_fails() { + // Index 5 is a right child at level 0, so that hint lane is pinned by the snapshot root and cannot be tampered + // with. Note this is only testable at a non-zero start index: appending into an empty tree pins no lane at all. + let mut builder = builder_at_non_aligned_index(!IS_FIRST_BLOCK_ROOT); + builder.l1_to_l2_message_frontier_hint[0] += 1; + + builder.execute_and_fail(); +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/mod.nr index 03e04d24b07f..0f2317947470 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/mod.nr @@ -1,10 +1,12 @@ mod child_proof_vk_tests; mod consecutive_rollups_tests; mod failures_tests; +mod message_bundle_tests; +mod msgs_only_tests; mod rollup_structure_tests; use crate::{ - abis::{BlockRollupPublicInputs, ParityPublicInputs, TxRollupPublicInputs}, + abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge, TxRollupPublicInputs}, block_root::{ block_root_empty_tx_first_rollup::{self, BlockRootEmptyTxFirstRollupPrivateInputs}, block_root_first_rollup::{self, BlockRootFirstRollupPrivateInputs}, @@ -21,14 +23,17 @@ use types::{ }, blob_data::SpongeBlob, constants::{ - ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, PARITY_ROOT_VK_INDEX, + ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, MAX_L1_TO_L2_MSGS_PER_BLOCK, PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PUBLIC_TX_BASE_ROLLUP_VK_INDEX, TX_MERGE_ROLLUP_VK_INDEX, }, hash::accumulate_sha256, merkle_tree::root_from_sibling_path, - traits::Hash, + traits::{Empty, Hash}, }; +// Default number of real L1-to-L2 messages in the block's bundle. Chosen non-zero so the tree and sponge both move. +global TEST_NUM_MSGS: u32 = 5; + struct TestBuilder { left_rollup: TxRollupPublicInputs, left_rollup_vk_index: u32, @@ -37,10 +42,14 @@ struct TestBuilder { right_rollup_vk_index: u32, num_right_txs: u16, is_first_block_root: bool, - parity_root: ParityPublicInputs, - parity_root_vk_index: u32, + // Message bundle appended by this block. + l1_to_l2_messages: [Field; MAX_L1_TO_L2_MSGS_PER_BLOCK], + num_msgs: u32, + l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT], previous_l1_to_l2: AppendOnlyTreeSnapshot, - new_l1_to_l2_message_subtree_root_sibling_path: [Field; L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH], + new_l1_to_l2: AppendOnlyTreeSnapshot, + // Message sponge inherited from the previous block (empty for first blocks). + start_msg_sponge: L1ToL2MessageSponge, new_archive_sibling_path: [Field; ARCHIVE_HEIGHT], checkpoint_constants: CheckpointConstantData, } @@ -78,6 +87,26 @@ impl TestBuilder { right_rollup_vk_index: u32, num_right_txs: u16, is_first_block_root: bool, + ) -> Self { + Self::new_at_l1_to_l2_index( + left_rollup_vk_index, + num_left_txs, + right_rollup_vk_index, + num_right_txs, + is_first_block_root, + 0, + ) + } + + /// Same as `new`, but the block's bundle is appended into an l1-to-l2 tree that already holds + /// `l1_to_l2_start_index` leaves instead of into an empty one. + pub fn new_at_l1_to_l2_index( + left_rollup_vk_index: u32, + num_left_txs: u16, + right_rollup_vk_index: u32, + num_right_txs: u16, + is_first_block_root: bool, + l1_to_l2_start_index: u32, ) -> Self { Self::validate_input_vk_index(left_rollup_vk_index, num_left_txs); Self::validate_input_vk_index(right_rollup_vk_index, num_right_txs); @@ -95,13 +124,23 @@ impl TestBuilder { ); let slot_number = fixture_builder.start_slot_number; - let parity_root = fixture_builder.get_parity_public_inputs(slot_number); - let (previous_l1_to_l2, new_l1_to_l2_message_subtree_root_sibling_path, new_l1_to_l2) = - fixture_builder.build_l1_to_l2_message_subtree_for_insertion(slot_number); + // Build the block's message bundle appended at the l1-to-l2 tree's next available index. + let (previous_l1_to_l2, l1_to_l2_messages, l1_to_l2_message_frontier_hint, new_l1_to_l2) = fixture_builder + .build_l1_to_l2_message_bundle_at_index(TEST_NUM_MSGS, l1_to_l2_start_index); + + // Every tx-carrying block-root variant (first and non-first) asserts the l1-to-l2 tree snapshot carried in the + // tx constants equals the post-append snapshot, so its txs read the messages this block inserts. left_rollup.constants.l1_to_l2_tree_snapshot = new_l1_to_l2; right_rollup.constants.l1_to_l2_tree_snapshot = new_l1_to_l2; + // First blocks start the message sponge from empty; non-first blocks inherit a (non-empty) sponge. + let start_msg_sponge = if is_first_block_root { + L1ToL2MessageSponge::empty() + } else { + fixture_builder.get_msg_sponge(slot_number) + }; + let block_number = fixture_builder.start_block_number; let (previous_archive, new_archive_sibling_path) = fixture_builder.build_archive_tree_for_insertion(block_number); @@ -118,10 +157,12 @@ impl TestBuilder { right_rollup_vk_index, num_right_txs, is_first_block_root, - parity_root, - parity_root_vk_index: PARITY_ROOT_VK_INDEX, + l1_to_l2_messages, + num_msgs: TEST_NUM_MSGS, + l1_to_l2_message_frontier_hint, previous_l1_to_l2, - new_l1_to_l2_message_subtree_root_sibling_path, + new_l1_to_l2, + start_msg_sponge, new_archive_sibling_path, checkpoint_constants, } @@ -154,16 +195,13 @@ impl TestBuilder { } fn execute_first_block_root(self) -> BlockRollupPublicInputs { - let parity_root = - RollupFixtureBuilder::make_proof_data(self.parity_root, self.parity_root_vk_index); - let previous_rollups = [ RollupFixtureBuilder::make_proof_data(self.left_rollup, self.left_rollup_vk_index), RollupFixtureBuilder::make_proof_data(self.right_rollup, self.right_rollup_vk_index), ]; - let new_l1_to_l2_message_subtree_root_sibling_path = - self.new_l1_to_l2_message_subtree_root_sibling_path; + let message_bundle = self.message_bundle(); + let l1_to_l2_message_frontier_hint = self.l1_to_l2_message_frontier_hint; let new_archive_sibling_path = self.new_archive_sibling_path; if self.num_left_txs == 0 { @@ -174,32 +212,32 @@ impl TestBuilder { }; block_root_empty_tx_first_rollup::execute( BlockRootEmptyTxFirstRollupPrivateInputs { - parity_root, previous_archive: left.constants.last_archive, previous_state, constants: self.checkpoint_constants, timestamp: left.constants.global_variables.timestamp, - new_l1_to_l2_message_subtree_root_sibling_path, + message_bundle, + l1_to_l2_message_frontier_hint, new_archive_sibling_path, }, ) } else if self.num_right_txs == 0 { block_root_single_tx_first_rollup::execute( BlockRootSingleTxFirstRollupPrivateInputs { - parity_root, previous_rollup: previous_rollups[0], + message_bundle, previous_l1_to_l2: self.previous_l1_to_l2, - new_l1_to_l2_message_subtree_root_sibling_path, + l1_to_l2_message_frontier_hint, new_archive_sibling_path, }, ) } else { block_root_first_rollup::execute( BlockRootFirstRollupPrivateInputs { - parity_root, previous_rollups, + message_bundle, previous_l1_to_l2: self.previous_l1_to_l2, - new_l1_to_l2_message_subtree_root_sibling_path, + l1_to_l2_message_frontier_hint, new_archive_sibling_path, }, ) @@ -212,22 +250,47 @@ impl TestBuilder { RollupFixtureBuilder::make_proof_data(self.right_rollup, self.right_rollup_vk_index), ]; + let message_bundle = self.message_bundle(); + let l1_to_l2_message_frontier_hint = self.l1_to_l2_message_frontier_hint; + let start_msg_sponge = self.start_msg_sponge; let new_archive_sibling_path = self.new_archive_sibling_path; if self.num_right_txs == 0 { block_root_single_tx_rollup::execute( BlockRootSingleTxRollupPrivateInputs { previous_rollup: previous_rollups[0], + message_bundle, + previous_l1_to_l2: self.previous_l1_to_l2, + start_msg_sponge, + l1_to_l2_message_frontier_hint, new_archive_sibling_path, }, ) } else { block_root_rollup::execute( - BlockRootRollupPrivateInputs { previous_rollups, new_archive_sibling_path }, + BlockRootRollupPrivateInputs { + previous_rollups, + message_bundle, + previous_l1_to_l2: self.previous_l1_to_l2, + start_msg_sponge, + l1_to_l2_message_frontier_hint, + new_archive_sibling_path, + }, ) } } + // The block's message bundle. The unit-test fixture inserts exactly `num_msgs` real leaves into the tree, so the + // tree-insert count and the sponge real-count are equal here; the transitional gap between them (padded tree + // insert vs real-count sponge) is exercised by the orchestrator and full-rollup tests. + fn message_bundle(self) -> L1ToL2MessageBundle { + L1ToL2MessageBundle { + messages: self.l1_to_l2_messages, + num_msgs: self.num_msgs, + num_real_msgs: self.num_msgs, + } + } + pub fn assert_expected_public_inputs(self, pi: BlockRollupPublicInputs) { // The private inputs of the empty block root are also constructed from the left rollup. let left = self.left_rollup; @@ -327,30 +390,30 @@ impl TestBuilder { // --- L1 to L2 message tree --- - let expected_previous_l1_to_l2 = if self.is_first_block_root { - self.previous_l1_to_l2 - } else { - self.left_rollup.constants.l1_to_l2_tree_snapshot - }; - assert_eq(pi.start_state.l1_to_l2_message_tree, expected_previous_l1_to_l2); - - assert_eq( - pi.end_state.l1_to_l2_message_tree, - self.left_rollup.constants.l1_to_l2_tree_snapshot, - ); + // Every block appends its bundle, so the state ref moves from the pre-append snapshot to the post-append one. + assert_eq(pi.start_state.l1_to_l2_message_tree, self.previous_l1_to_l2); + assert_eq(pi.end_state.l1_to_l2_message_tree, self.new_l1_to_l2); // --- Timestamps --- assert_eq(pi.timestamp, left.constants.global_variables.timestamp); - // --- In hash --- + // --- is_first_block --- - let expected_in_hash = if self.is_first_block_root { - self.parity_root.sha_root + assert_eq(pi.is_first_block, self.is_first_block_root); + + // --- Message sponge --- + + let expected_start_msg_sponge = if self.is_first_block_root { + L1ToL2MessageSponge::empty() } else { - 0 + self.start_msg_sponge }; - assert_eq(pi.in_hash, expected_in_hash); + assert_eq(pi.start_msg_sponge, expected_start_msg_sponge); + + let mut expected_end_msg_sponge = expected_start_msg_sponge; + expected_end_msg_sponge.absorb(self.l1_to_l2_messages, self.num_msgs); + assert_eq(pi.end_msg_sponge, expected_end_msg_sponge); // --- Out hash -- diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/msgs_only_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/msgs_only_tests.nr new file mode 100644 index 000000000000..a1f92176146c --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/block_root/tests/msgs_only_tests.nr @@ -0,0 +1,187 @@ +use crate::{ + abis::{BlockRollupPublicInputs, L1ToL2MessageBundle, L1ToL2MessageSponge}, + block_root::block_root_msgs_only_rollup::{self, BlockRootMsgsOnlyRollupPrivateInputs}, + tests::RollupFixtureBuilder, +}; +use types::{ + abis::{ + append_only_tree_snapshot::AppendOnlyTreeSnapshot, block_header::BlockHeader, + checkpoint_constant_data::CheckpointConstantData, global_variables::GlobalVariables, + partial_state_reference::PartialStateReference, state_reference::StateReference, + }, + blob_data::SpongeBlob, + constants::{ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, MAX_L1_TO_L2_MSGS_PER_BLOCK}, + merkle_tree::root_from_sibling_path, + traits::Hash, +}; + +global TEST_NUM_MSGS: u32 = 5; + +// Builds the inputs for a non-first, transaction-less block that inserts an L1-to-L2 message bundle. +struct TestBuilder { + previous_archive: AppendOnlyTreeSnapshot, + previous_state: StateReference, + constants: CheckpointConstantData, + timestamp: u64, + start_sponge_blob: SpongeBlob, + start_msg_sponge: L1ToL2MessageSponge, + l1_to_l2_messages: [Field; MAX_L1_TO_L2_MSGS_PER_BLOCK], + num_msgs: u32, + l1_to_l2_message_frontier_hint: [Field; L1_TO_L2_MSG_TREE_HEIGHT], + new_archive_sibling_path: [Field; ARCHIVE_HEIGHT], + // Retained for assertions. + new_l1_to_l2: AppendOnlyTreeSnapshot, + partial: PartialStateReference, +} + +impl TestBuilder { + pub fn new() -> Self { + let fixture_builder = RollupFixtureBuilder::new(); + let slot_number = fixture_builder.start_slot_number; + let block_number = fixture_builder.start_block_number; + + let (previous_l1_to_l2, l1_to_l2_messages, l1_to_l2_message_frontier_hint, new_l1_to_l2) = + fixture_builder.build_l1_to_l2_message_bundle(TEST_NUM_MSGS); + + let (previous_archive, new_archive_sibling_path) = + fixture_builder.build_archive_tree_for_insertion(block_number); + + // Borrow a partial state from a tx rollup fixture; it is simply propagated to the start and end states. + let partial = fixture_builder.get_tx_rollup_public_inputs(6).start_tree_snapshots; + let previous_state = + StateReference { l1_to_l2_message_tree: previous_l1_to_l2, partial }; + + Self { + previous_archive, + previous_state, + constants: fixture_builder.get_checkpoint_constant_data(slot_number), + timestamp: fixture_builder.get_global_variables(block_number).timestamp, + // A non-first block inherits a non-empty sponge blob and message sponge from the previous block. + start_sponge_blob: fixture_builder.get_sponge_blob(block_number), + start_msg_sponge: fixture_builder.get_msg_sponge(slot_number), + l1_to_l2_messages, + num_msgs: TEST_NUM_MSGS, + l1_to_l2_message_frontier_hint, + new_archive_sibling_path, + new_l1_to_l2, + partial, + } + } + + fn to_inputs(self) -> BlockRootMsgsOnlyRollupPrivateInputs { + BlockRootMsgsOnlyRollupPrivateInputs { + previous_archive: self.previous_archive, + previous_state: self.previous_state, + constants: self.constants, + timestamp: self.timestamp, + start_sponge_blob: self.start_sponge_blob, + start_msg_sponge: self.start_msg_sponge, + message_bundle: L1ToL2MessageBundle { + messages: self.l1_to_l2_messages, + num_msgs: self.num_msgs, + num_real_msgs: self.num_msgs, + }, + l1_to_l2_message_frontier_hint: self.l1_to_l2_message_frontier_hint, + new_archive_sibling_path: self.new_archive_sibling_path, + } + } + + pub fn execute(self) -> BlockRollupPublicInputs { + block_root_msgs_only_rollup::execute(self.to_inputs()) + } + + pub fn execute_and_fail(self) { + let _ = self.execute(); + } + + pub fn assert_expected_public_inputs(self, pi: BlockRollupPublicInputs) { + // A message-only block is a single, non-first block. + assert_eq(pi.num_blocks(), 1); + assert_eq(pi.constants, self.constants); + assert(!pi.is_first_block); + + // --- Sponge blobs: threaded from the (non-empty) provided start, with the block end data absorbed. --- + assert_eq(pi.start_sponge_blob, self.start_sponge_blob); + let mut expected_end_sponge_blob = self.start_sponge_blob; + expected_end_sponge_blob.absorb_block_end_data( + self.constants_as_global_variables(), + pi.previous_archive, + pi.end_state, + 0, // num_txs + 0, // total_mana_used + false, // is_first_block + ); + assert_eq(pi.end_sponge_blob, expected_end_sponge_blob); + + // --- Message sponge: threaded from the provided start, absorbing this block's bundle. --- + assert_eq(pi.start_msg_sponge, self.start_msg_sponge); + let mut expected_end_msg_sponge = self.start_msg_sponge; + expected_end_msg_sponge.absorb(self.l1_to_l2_messages, self.num_msgs); + assert_eq(pi.end_msg_sponge, expected_end_msg_sponge); + + // --- Archive: the block header hash is inserted at the next available index. --- + assert_eq(pi.previous_archive, self.previous_archive); + let sponge_blob_hash = expected_end_sponge_blob.squeeze(); + let block_header = BlockHeader { + last_archive: pi.previous_archive, + state: pi.end_state, + sponge_blob_hash, + global_variables: self.constants_as_global_variables(), + total_fees: pi.accumulated_fees, + total_mana_used: pi.accumulated_mana_used, + }; + let expected_archive_root = root_from_sibling_path( + block_header.hash(), + pi.previous_archive.next_available_leaf_index, + self.new_archive_sibling_path, + ); + assert_eq(pi.new_archive.root, expected_archive_root); + assert_eq( + pi.new_archive.next_available_leaf_index, + pi.previous_archive.next_available_leaf_index + 1, + ); + + // --- State: partial unchanged (no tx effects), l1-to-l2 tree moves by the appended bundle. --- + assert_eq(pi.start_state.partial, self.partial); + assert_eq(pi.end_state.partial, self.partial); + assert_eq(pi.start_state.l1_to_l2_message_tree, self.previous_state.l1_to_l2_message_tree); + assert_eq(pi.end_state.l1_to_l2_message_tree, self.new_l1_to_l2); + + // --- Timestamp / no tx effects. --- + assert_eq(pi.timestamp, self.timestamp); + assert_eq(pi.out_hash, 0); + assert_eq(pi.accumulated_fees, 0); + assert_eq(pi.accumulated_mana_used, 0); + } + + fn constants_as_global_variables(self) -> GlobalVariables { + GlobalVariables { + chain_id: self.constants.chain_id, + version: self.constants.version, + block_number: self.previous_archive.next_available_leaf_index as u32, + slot_number: self.constants.slot_number, + timestamp: self.timestamp, + coinbase: self.constants.coinbase, + fee_recipient: self.constants.fee_recipient, + gas_fees: self.constants.gas_fees, + } + } +} + +#[test] +fn msgs_only_block_root_success() { + let builder = TestBuilder::new(); + let pi = builder.execute(); + builder.assert_expected_public_inputs(pi); +} + +#[test(should_fail_with = "A message-only block must insert at least one L1-to-L2 message")] +fn msgs_only_block_root_rejects_empty_bundle() { + let mut builder = TestBuilder::new(); + + // A non-first empty block with no messages has no reason to exist and must be rejected. + builder.num_msgs = 0; + builder.l1_to_l2_messages = [0; MAX_L1_TO_L2_MSGS_PER_BLOCK]; + + builder.execute_and_fail(); +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/tests/consecutive_checkpoint_rollups_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/tests/consecutive_checkpoint_rollups_tests.nr index 060d9a2d4e28..a6f865298ba1 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/tests/consecutive_checkpoint_rollups_tests.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/tests/consecutive_checkpoint_rollups_tests.nr @@ -238,6 +238,18 @@ fn non_consecutive_out_hash_next_available_leaf_indices() { builder.execute_and_fail(); } +// --- inbox rolling hash --- + +#[test(should_fail_with = "Mismatched inbox rolling hash: expected right.start to match left.end")] +fn non_consecutive_inbox_rolling_hash() { + let mut builder = TestBuilder::default(); + + // Break the continuity of the rolling-hash chain between the two checkpoints. + builder.right_rollup.start_inbox_rolling_hash += 1; + + builder.execute_and_fail(); +} + // --- blob accumulators --- #[test(should_fail_with = "Mismatched blob accumulators: expected right.start_blob_accumulator to match left.end_blob_accumulator")] diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/tests/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/tests/mod.nr index 96f8a16da3ee..c4e7c8eb6f44 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/tests/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/tests/mod.nr @@ -107,6 +107,11 @@ impl TestBuilder { assert_eq(pi.new_out_hash, right.new_out_hash); assert(pi.previous_out_hash != pi.new_out_hash); + // The merged range spans from the left checkpoint's start to the right checkpoint's end; continuity across the + // two ranges is enforced in `validate_consecutive_checkpoint_rollups`. + assert_eq(pi.start_inbox_rolling_hash, left.start_inbox_rolling_hash); + assert_eq(pi.end_inbox_rolling_hash, right.end_inbox_rolling_hash); + let mut expected_header_hashes = [0; MAX_CHECKPOINTS_PER_EPOCH]; let mut expected_fees = [FeeRecipient::empty(); MAX_CHECKPOINTS_PER_EPOCH]; for i in 0..self.num_left_checkpoints as u32 { diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/utils/merge_checkpoint_rollups.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/utils/merge_checkpoint_rollups.nr index 0470e80e0c17..68a28c843fe0 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/utils/merge_checkpoint_rollups.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/utils/merge_checkpoint_rollups.nr @@ -55,6 +55,10 @@ pub fn merge_checkpoint_rollups( new_archive: right.new_archive, previous_out_hash: left.previous_out_hash, new_out_hash: right.new_out_hash, + // The rolling-hash chain spans both checkpoint ranges: start from the left, end at the right. Continuity + // (`right.start == left.end`) is asserted in `validate_consecutive_checkpoint_rollups`. + start_inbox_rolling_hash: left.start_inbox_rolling_hash, + end_inbox_rolling_hash: right.end_inbox_rolling_hash, checkpoint_header_hashes, fees, start_blob_accumulator: left.start_blob_accumulator, diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/utils/validate_consecutive_checkpoint_rollups.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/utils/validate_consecutive_checkpoint_rollups.nr index 8d4fd24bd73b..7d00876625e2 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/utils/validate_consecutive_checkpoint_rollups.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_merge/utils/validate_consecutive_checkpoint_rollups.nr @@ -29,6 +29,15 @@ fn assert_rollups_follow_on_from_each_other( "Mismatched out hashes: expected right.previous_out_hash to match left.new_out_hash", ); + // The inbox rolling-hash chain must be continuous across consecutive checkpoints: the right checkpoint's chain must + // start where the left checkpoint's chain ended. An end-only anchor would let a prover restart the chain from an + // earlier bucket and re-insert already-consumed messages, so continuity is enforced here. + assert_eq( + left.end_inbox_rolling_hash, + right.start_inbox_rolling_hash, + "Mismatched inbox rolling hash: expected right.start to match left.end", + ); + assert_eq( left.end_blob_accumulator, right.start_blob_accumulator, diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/checkpoint_root_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/checkpoint_root_rollup.nr index 4b7c73a8e7b9..f93765f7410a 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/checkpoint_root_rollup.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/checkpoint_root_rollup.nr @@ -1,7 +1,7 @@ use crate::{ - abis::{BlockRollupPublicInputs, CheckpointRollupPublicInputs}, + abis::{BlockRollupPublicInputs, CheckpointRollupPublicInputs, ParityPublicInputs}, checkpoint_root::components::{ - CheckpointRollupPublicInputsComposer, CheckpointRootInputsValidator, + CheckpointRollupPublicInputsComposer, CheckpointRootInputsValidator, validate_inbox_parity, }, }; use blob::abis::{BlobAccumulator, BLSPoint, FinalBlobBatchingChallenges}; @@ -10,23 +10,28 @@ use types::{ constants::{ ARCHIVE_HEIGHT, BLOBS_PER_CHECKPOINT, BLOCK_MERGE_ROLLUP_VK_INDEX, BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, - BLOCK_ROOT_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, - BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, FIELDS_PER_BLOB, OUT_HASH_TREE_HEIGHT, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, BLOCK_ROOT_ROLLUP_VK_INDEX, + BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, + FIELDS_PER_BLOB, OUT_HASH_TREE_HEIGHT, }, - proof::proof_data::RollupHonkProofData, + proof::proof_data::{RollupHonkProofData, UltraHonkProofData}, }; -global ALLOWED_PREVIOUS_VK_INDICES: [u32; 6] = [ +global ALLOWED_PREVIOUS_VK_INDICES: [u32; 7] = [ BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, BLOCK_MERGE_ROLLUP_VK_INDEX, ]; pub struct CheckpointRootRollupPrivateInputs { pub(crate) previous_rollups: [RollupHonkProofData; 2], + // Inbox parity proof over the checkpoint's L1-to-L2 messages. One variable-size proof per checkpoint: the + // checkpoint root is the only circuit that sees the whole checkpoint's message commitments. + pub(crate) inbox_parity: UltraHonkProofData, pub(crate) hints: CheckpointRootRollupHints, } @@ -94,8 +99,13 @@ pub fn execute(inputs: CheckpointRootRollupPrivateInputs) -> CheckpointRollupPub .validate(); let previous_rollups = inputs.previous_rollups.map(|rollup| rollup.public_inputs); + + let constants = previous_rollups[0].constants; + validate_inbox_parity(inputs.inbox_parity, constants.vk_tree_root, constants.prover_id); + CheckpointRollupPublicInputsComposer::new( previous_rollups, + inputs.inbox_parity.public_inputs, hints.previous_out_hash, hints.new_out_hash_sibling_path, hints.start_blob_accumulator, diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/checkpoint_root_single_block_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/checkpoint_root_single_block_rollup.nr index b01107e7557e..79a4ef5f2f1a 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/checkpoint_root_single_block_rollup.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/checkpoint_root_single_block_rollup.nr @@ -1,27 +1,40 @@ use crate::{ - abis::{BlockRollupPublicInputs, CheckpointRollupPublicInputs}, + abis::{BlockRollupPublicInputs, CheckpointRollupPublicInputs, ParityPublicInputs}, checkpoint_root::{ checkpoint_root_rollup::CheckpointRootRollupHints, - components::{CheckpointRollupPublicInputsComposer, CheckpointRootInputsValidator}, + components::{ + CheckpointRollupPublicInputsComposer, CheckpointRootInputsValidator, validate_inbox_parity, + }, }, }; use types::{ constants::{ BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, - BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, }, - proof::proof_data::RollupHonkProofData, + proof::proof_data::{RollupHonkProofData, UltraHonkProofData}, }; -// If there's only one previous rollup (i.e., one block in the checkpoint), it must be the first block root rollup. -global ALLOWED_PREVIOUS_VK_INDICES: [u32; 3] = [ +// If there's only one previous rollup (i.e., one block in the checkpoint), it must be a first block root: the inputs +// validator asserts the leftmost rollup's `is_first_block`. The message-only block root sets `is_first_block = false`, +// so it is listed here (for symmetry with the multi-block variant) but can never actually pass as the sole block. +// +// That `is_first_block` assertion is the only thing keeping a message-only block from standing as a checkpoint's sole +// block. If it is ever relaxed (e.g. replaced by a "leftmost block's start_msg_sponge is empty" check), this entry +// must be dropped in the same change, or a transaction-less single-block checkpoint — one whose blob omits the +// first-block l1-to-l2 root — would silently become provable. +global ALLOWED_PREVIOUS_VK_INDICES: [u32; 4] = [ BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, ]; pub struct CheckpointRootSingleBlockRollupPrivateInputs { pub(crate) previous_rollup: RollupHonkProofData, + // Inbox parity proof over the checkpoint's L1-to-L2 messages. One variable-size proof per checkpoint: the + // checkpoint root is the only circuit that sees the whole checkpoint's message commitments. + pub(crate) inbox_parity: UltraHonkProofData, pub(crate) hints: CheckpointRootRollupHints, } @@ -55,8 +68,12 @@ pub fn execute( ) .validate(); + let constants = inputs.previous_rollup.public_inputs.constants; + validate_inbox_parity(inputs.inbox_parity, constants.vk_tree_root, constants.prover_id); + CheckpointRollupPublicInputsComposer::new( [inputs.previous_rollup.public_inputs], + inputs.inbox_parity.public_inputs, hints.previous_out_hash, hints.new_out_hash_sibling_path, hints.start_blob_accumulator, diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/checkpoint_rollup_public_inputs_composer.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/checkpoint_rollup_public_inputs_composer.nr index c9f52a742e63..56aa0e132933 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/checkpoint_rollup_public_inputs_composer.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/checkpoint_rollup_public_inputs_composer.nr @@ -1,5 +1,5 @@ use crate::{ - abis::{BlockRollupPublicInputs, CheckpointRollupPublicInputs}, + abis::{BlockRollupPublicInputs, CheckpointRollupPublicInputs, L1ToL2MessageSponge, ParityPublicInputs}, block_merge::merge_block_rollups, }; use bignum::BLS12_381_Fr; @@ -21,6 +21,9 @@ use types::{ pub struct CheckpointRollupPublicInputsComposer { merged_rollup: BlockRollupPublicInputs, + // Public inputs of the inbox parity proof (verified by the caller). The checkpoint's `in_hash` and + // `inbox_rolling_hash` are sourced from it, and its message sponge is checked against the blocks' accumulated one. + parity: ParityPublicInputs, // The below are all hints: previous_out_hash: AppendOnlyTreeSnapshot, new_out_hash_sibling_path: [Field; OUT_HASH_TREE_HEIGHT], @@ -34,6 +37,7 @@ pub struct CheckpointRollupPublicInputsComposer { impl CheckpointRollupPublicInputsComposer { pub fn new( previous_rollups: [BlockRollupPublicInputs; NumPreviousRollups], + parity: ParityPublicInputs, // The below args are all hints: previous_out_hash: AppendOnlyTreeSnapshot, new_out_hash_sibling_path: [Field; OUT_HASH_TREE_HEIGHT], @@ -50,6 +54,7 @@ impl CheckpointRollupPublicInputsComposer { Self { merged_rollup, + parity, previous_out_hash, new_out_hash_sibling_path, start_blob_accumulator, @@ -63,6 +68,22 @@ impl CheckpointRollupPublicInputsComposer { pub fn finish(self) -> CheckpointRollupPublicInputs { let merged_rollup = self.merged_rollup; + // The inbox parity sponge must start empty (the message sponge resets per checkpoint) and must equal the + // sponge accumulated across this checkpoint's block roots. Together with the leftmost block starting from the + // empty sponge (checked in the inputs validator) and the per-block continuity checks in the block merge + // circuit, this proves the blocks inserted exactly the parity-committed message list, in order — no leaf + // arrays cross the circuit boundary. + assert_eq( + self.parity.start_sponge, + L1ToL2MessageSponge::empty(), + "The inbox parity message sponge must start empty", + ); + assert_eq( + merged_rollup.end_msg_sponge, + self.parity.end_sponge, + "The blocks' message sponge does not match the inbox parity's message sponge", + ); + let constants = EpochConstantData { chain_id: merged_rollup.constants.chain_id, version: merged_rollup.constants.version, @@ -96,6 +117,10 @@ impl CheckpointRollupPublicInputsComposer { new_archive: merged_rollup.new_archive, previous_out_hash: self.previous_out_hash, new_out_hash, + // Sourced from the inbox parity proof, which commits to the same message list behind the L1-checked + // `in_hash`. Checkpoint merges assert continuity across checkpoints (`right.start == left.end`). + start_inbox_rolling_hash: self.parity.start_rolling_hash, + end_inbox_rolling_hash: self.parity.end_rolling_hash, checkpoint_header_hashes, fees, start_blob_accumulator: self.start_blob_accumulator, @@ -120,7 +145,11 @@ impl CheckpointRollupPublicInputsComposer { last_archive_root: merged_rollup.previous_archive.root, block_headers_hash: merged_rollup.block_headers_hash, blobs_hash: self.blobs_hash, - in_hash: merged_rollup.in_hash, + // `in_hash` (the sha256 frontier root, checked on L1) and `inbox_rolling_hash` are sourced from the inbox + // parity proof. `in_hash` is an unconstrained pass-through there (see `ParityPublicInputs::in_hash`); it + // remains the authoritative L1 check until the Fast Inbox flip. + in_hash: self.parity.in_hash, + inbox_rolling_hash: self.parity.end_rolling_hash, epoch_out_hash, slot_number: constants.slot_number, timestamp: merged_rollup.timestamp, diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/checkpoint_root_inputs_validator.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/checkpoint_root_inputs_validator.nr index f84d83e48071..be280142a773 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/checkpoint_root_inputs_validator.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/checkpoint_root_inputs_validator.nr @@ -1,11 +1,14 @@ -use crate::{abis::BlockRollupPublicInputs, block_merge::validate_consecutive_block_rollups}; +use crate::{ + abis::{BlockRollupPublicInputs, L1ToL2MessageSponge}, + block_merge::validate_consecutive_block_rollups, +}; use types::{ abis::block_header::BlockHeader, blob_data::SpongeBlob, constants::ARCHIVE_HEIGHT, merkle_tree::{check_membership, MembershipWitness}, proof::proof_data::RollupHonkProofData, - traits::Hash, + traits::{Empty, Hash}, }; pub struct CheckpointRootInputsValidator { @@ -86,15 +89,21 @@ impl CheckpointRootInputsVal "The start timestamp must be after the previous block's timestamp", ); - // `in_hash` must be set using the **first** block root rollup circuit for the first block in a checkpoint. - // In `validate_consecutive_block_rollups`, it ensures that the hash only propagates through all merge steps - // exclusively via the left rollup. The value in the left rollup must not be 0 when it reaches the checkpoint - // root (this point). - // Note: If the L1 subtree being copied to L2 is empty, then the in_hash will be the root of a tree whose - // leaves are empty (0) messages. + // The leftmost block of the checkpoint must be a first block root, which is the only variant that sets + // `is_first_block`. `validate_consecutive_block_rollups` asserts every non-first ("right") rollup is not a + // first block, so the merged value can only be true if the leftmost leaf is a first block root. assert( - first_rollup.in_hash != 0, - "in_hash must be set via the first block root in the checkpoint", + first_rollup.is_first_block, + "The first block of the checkpoint must be a first block root", + ); + + // The message sponge resets per checkpoint, so the leftmost block must start from the empty sponge. Combined + // with the checkpoint root asserting the merged end equals the parity root's sponge, this anchors the sponge + // chain to exactly this checkpoint's messages. + assert_eq( + first_rollup.start_msg_sponge, + L1ToL2MessageSponge::empty(), + "The message sponge of the first block was not correctly initialized", ); // `previous_block_header` is provided as a private input and is used to validate the values above. diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/mod.nr index b3e5c7e41e2b..e665b4971813 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/mod.nr @@ -1,5 +1,7 @@ mod checkpoint_root_inputs_validator; mod checkpoint_rollup_public_inputs_composer; +mod validate_inbox_parity; pub use checkpoint_rollup_public_inputs_composer::CheckpointRollupPublicInputsComposer; pub use checkpoint_root_inputs_validator::CheckpointRootInputsValidator; +pub use validate_inbox_parity::validate_inbox_parity; diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/validate_inbox_parity.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/validate_inbox_parity.nr new file mode 100644 index 000000000000..858c613d8229 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/components/validate_inbox_parity.nr @@ -0,0 +1,40 @@ +use crate::abis::ParityPublicInputs; +use types::{ + constants::{INBOX_PARITY_1024_VK_INDEX, INBOX_PARITY_256_VK_INDEX, INBOX_PARITY_64_VK_INDEX}, + proof::proof_data::UltraHonkProofData, +}; + +/// Verify the checkpoint's `InboxParity` proof and vk, and check that its vk tree root and prover_id equal the ones in +/// the checkpoint's constants. The proof may be any rung of the size ladder, so the vk index is checked against the +/// allowed `{64, 256, 1024}` set rather than a single value. +pub fn validate_inbox_parity( + data: UltraHonkProofData, + vk_tree_root: Field, + prover_id: Field, +) { + if !::std::runtime::is_unconstrained() { + data.verify_proof(); + } + + // Check that the `vk_tree_root` in the public inputs matches the one in the checkpoint's constants, as it was used + // to verify the vk of the inbox parity proof. + assert_eq( + data.public_inputs.vk_tree_root, + vk_tree_root, + "The vk tree root of the inbox parity does not match the rollup's vk tree root", + ); + + // Check that the `prover_id` in the public inputs matches the one in the checkpoint's constants, preventing sybil + // attacks where the same prover submits an inbox parity proof under different identities. + assert_eq( + data.public_inputs.prover_id, + prover_id, + "The prover id of the inbox parity does not match the rollup's prover id", + ); + + // The proof may be any rung of the size ladder, so accept the whole `{64, 256, 1024}` vk-index set. + data.vk_data.validate_allowed_in_vk_tree( + vk_tree_root, + [INBOX_PARITY_64_VK_INDEX, INBOX_PARITY_256_VK_INDEX, INBOX_PARITY_1024_VK_INDEX], + ); +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/consecutive_rollups_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/consecutive_rollups_tests.nr index 30f2889c8f23..320978dc0bdc 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/consecutive_rollups_tests.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/consecutive_rollups_tests.nr @@ -4,11 +4,11 @@ use super::TestBuilder; // validating consecutive block rollups can be found in `block_merge/tests/consecutive_block_rollups_tests.nr`. // Tests for merging out hashes can be found in `out_hash_tests.nr`. -#[test(should_fail_with = "Right rollup must not carry in_hash")] -fn non_zero_in_hash_in_right_rollup() { +#[test(should_fail_with = "Right rollup must not be a first block")] +fn first_block_in_right_rollup() { let mut builder = TestBuilder::default(); - builder.right_rollup.in_hash = 123; + builder.right_rollup.is_first_block = true; builder.execute_with_mock_and_fail(); } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/mod.nr index ad894c973294..38b92d5163e4 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/mod.nr @@ -1,12 +1,14 @@ mod blob_tests; mod child_proof_vk_tests; mod consecutive_rollups_tests; +mod msgs_only_tests; mod out_hash_tests; +mod parity_tests; mod rollup_structure_tests; mod start_states_tests; use crate::{ - abis::{BlockRollupPublicInputs, CheckpointRollupPublicInputs}, + abis::{BlockRollupPublicInputs, CheckpointRollupPublicInputs, ParityPublicInputs}, block_merge::accumulate_block_headers_hash, checkpoint_root::{ checkpoint_root_rollup::{ @@ -27,9 +29,9 @@ use types::{ blob_data::{create_checkpoint_end_marker, SpongeBlob}, constants::{ BLOCK_MERGE_ROLLUP_VK_INDEX, BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX, - BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_ROLLUP_VK_INDEX, - BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, - OUT_HASH_TREE_LEAF_COUNT, + BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, + BLOCK_ROOT_ROLLUP_VK_INDEX, BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX, + BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, INBOX_PARITY_1024_VK_INDEX, OUT_HASH_TREE_LEAF_COUNT, }, merkle_tree::compute_sha_tree_root, traits::{Hash, Serialize}, @@ -48,6 +50,8 @@ struct TestBuilder { right_rollup: BlockRollupPublicInputs, right_rollup_vk_index: u32, is_single_block: bool, + inbox_parity: ParityPublicInputs, + inbox_parity_vk_index: u32, hints: CheckpointRootRollupHints, } @@ -187,12 +191,19 @@ impl TestBuilder { // Update the start state of the left rollup to match the state of the previous block. left_rollup.start_state = hints.previous_block_header.state; + // The InboxParity proof commits to the same checkpoint messages the block roots absorbed. Its message sponge + // (empty to the checkpoint's accumulated value) matches the blocks' merged sponge; its rolling hash and in_hash + // feed the checkpoint header. Built at the base slot the block fixtures use for their sponge. + let inbox_parity = fixture_builder.get_parity_public_inputs(fixture_builder.start_slot_number); + Self { fixture_builder, left_rollup, left_rollup_vk_index, right_rollup, right_rollup_vk_index, + inbox_parity, + inbox_parity_vk_index: INBOX_PARITY_1024_VK_INDEX, hints, is_single_block, } @@ -252,12 +263,16 @@ impl TestBuilder { | (vk_index == BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP_VK_INDEX) | (vk_index == BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX) | (vk_index == BLOCK_ROOT_ROLLUP_VK_INDEX) - | (vk_index == BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX), + | (vk_index == BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX) + | (vk_index == BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX), ); } } pub fn execute(self) -> CheckpointRollupPublicInputs { + let inbox_parity = + RollupFixtureBuilder::make_proof_data(self.inbox_parity, self.inbox_parity_vk_index); + if self.is_single_block { checkpoint_root_single_block_rollup::execute( CheckpointRootSingleBlockRollupPrivateInputs { @@ -265,6 +280,7 @@ impl TestBuilder { self.left_rollup, self.left_rollup_vk_index, ), + inbox_parity, hints: self.hints, }, ) @@ -281,6 +297,7 @@ impl TestBuilder { self.right_rollup_vk_index, ), ], + inbox_parity, hints: self.hints, }, ) @@ -340,6 +357,11 @@ impl TestBuilder { assert_eq(pi.new_archive, right.new_archive); assert(pi.previous_archive != pi.new_archive); + // The checkpoint's rolling-hash pair is sourced from the InboxParity proof (which commits to the checkpoint's + // full message list), not from the block rollups. + assert_eq(pi.start_inbox_rolling_hash, self.inbox_parity.start_rolling_hash); + assert_eq(pi.end_inbox_rolling_hash, self.inbox_parity.end_rolling_hash); + // Safety: This is just for testing. Unconstrained to speed up the tests. let expected_checkpoint_header = unsafe { self.get_expected_checkpoint_header() }; assert_array_eq( @@ -423,7 +445,8 @@ impl TestBuilder { last_archive_root: left.previous_archive.root, block_headers_hash, blobs_hash: self.hints.blobs_hash, - in_hash: left.in_hash, + in_hash: self.inbox_parity.in_hash, + inbox_rolling_hash: self.inbox_parity.end_rolling_hash, epoch_out_hash, slot_number: left.constants.slot_number, timestamp: right.timestamp, diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/msgs_only_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/msgs_only_tests.nr new file mode 100644 index 000000000000..444a26cac87a --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/msgs_only_tests.nr @@ -0,0 +1,30 @@ +use super::TestBuilder; +use types::constants::{BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, BLOCK_ROOT_ROLLUP_VK_INDEX, BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX}; + +// A checkpoint of [first block, message-only block] proves: the message-only block is accepted as a non-first direct +// child of the checkpoint root. +#[test] +fn checkpoint_with_msgs_only_right_block() { + let builder = TestBuilder::new( + BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, + 1, + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, + 1, + ); + let (pi, mock) = builder.execute_with_mock(); + builder.assert_expected_public_inputs(pi); + builder.assert_mock_called(mock); +} + +// The message-only block sets `is_first_block = false`, so it can never be the leftmost block of a checkpoint: the +// checkpoint root requires the leftmost rollup's `is_first_block` to be true. +#[test(should_fail_with = "The first block of the checkpoint must be a first block root")] +fn msgs_only_block_cannot_be_leftmost() { + let builder = TestBuilder::new( + BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, + 1, + BLOCK_ROOT_ROLLUP_VK_INDEX, + 1, + ); + builder.execute_with_mock_and_fail(); +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/parity_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/parity_tests.nr new file mode 100644 index 000000000000..f2776107e8f4 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/parity_tests.nr @@ -0,0 +1,106 @@ +use super::TestBuilder; +use protocol_test_utils::fixtures::vk_tree::{update_vk_hash, VK_MERKLE_TREE}; +use types::constants::{ + CHECKPOINT_ROOT_ROLLUP_VK_INDEX, INBOX_PARITY_256_VK_INDEX, INBOX_PARITY_64_VK_INDEX, +}; + +// --- Inbox parity proof / vk --- + +// The checkpoint root accepts any rung of the inbox parity size ladder. The default builder uses the 1024 rung; here +// we exercise the other two to prove the whole allowed set is accepted. +#[test] +fn accepts_ladder_vk_index_64() { + let mut builder = TestBuilder::default(); + builder.inbox_parity_vk_index = INBOX_PARITY_64_VK_INDEX; + let _ = builder.execute_with_mock(); +} + +#[test] +fn accepts_ladder_vk_index_256_single_block() { + let mut builder = TestBuilder::default_single_block(); + builder.inbox_parity_vk_index = INBOX_PARITY_256_VK_INDEX; + let _ = builder.execute_with_mock(); +} + +#[test(should_fail_with = "Vk index not in allowed list")] +fn incorrect_inbox_parity_vk_index() { + let mut builder = TestBuilder::default(); + + builder.inbox_parity_vk_index = CHECKPOINT_ROOT_ROLLUP_VK_INDEX; + + builder.execute_with_mock_and_fail(); +} + +#[test(should_fail_with = "Vk index not in allowed list")] +fn incorrect_inbox_parity_vk_index_single_block() { + let mut builder = TestBuilder::default_single_block(); + + builder.inbox_parity_vk_index = CHECKPOINT_ROOT_ROLLUP_VK_INDEX; + + builder.execute_with_mock_and_fail(); +} + +#[test(should_fail_with = "Membership check failed: vk hash not found in vk tree")] +fn inbox_parity_vk_not_in_vk_tree() { + let mut builder = TestBuilder::default(); + + // Update the inbox parity vk hash so that the old vk hash in the proof data is no longer in the vk tree. + let mut new_vk_tree = VK_MERKLE_TREE; + update_vk_hash(&mut new_vk_tree, builder.inbox_parity_vk_index, 999); + + builder.inbox_parity.vk_tree_root = new_vk_tree.get_root(); + builder.left_rollup.constants.vk_tree_root = new_vk_tree.get_root(); + builder.right_rollup.constants.vk_tree_root = new_vk_tree.get_root(); + + builder.execute_with_mock_and_fail(); +} + +#[test(should_fail_with = "The vk tree root of the inbox parity does not match the rollup's vk tree root")] +fn mismatched_vk_tree_root_from_parity() { + let mut builder = TestBuilder::default(); + + builder.inbox_parity.vk_tree_root += 1; + + builder.execute_with_mock_and_fail(); +} + +#[test(should_fail_with = "The prover id of the inbox parity does not match the rollup's prover id")] +fn mismatched_prover_id_from_parity() { + let mut builder = TestBuilder::default(); + + builder.inbox_parity.prover_id += 1; + + builder.execute_with_mock_and_fail(); +} + +// --- Message sponge --- + +#[test(should_fail_with = "The inbox parity message sponge must start empty")] +fn inbox_parity_sponge_not_empty() { + let mut builder = TestBuilder::default(); + + // The inbox parity's message sponge must reset per checkpoint (start empty). + builder.inbox_parity.start_sponge.num_absorbed += 1; + + builder.execute_with_mock_and_fail(); +} + +#[test(should_fail_with = "The blocks' message sponge does not match the inbox parity's message sponge")] +fn blocks_sponge_mismatch_parity() { + let mut builder = TestBuilder::default(); + + // Break the equality between the blocks' accumulated sponge and the inbox parity's sponge. + builder.inbox_parity.end_sponge.num_absorbed += 1; + + builder.execute_with_mock_and_fail(); +} + +#[test(should_fail_with = "The message sponge of the first block was not correctly initialized")] +fn first_block_start_sponge_not_empty() { + let mut builder = TestBuilder::default(); + + // The first block must start the message sponge from empty. + builder.left_rollup.start_msg_sponge.num_absorbed += 1; + + builder.execute_with_mock_and_fail(); +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/rollup_structure_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/rollup_structure_tests.nr index cf75a3c16921..c800a306a75b 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/rollup_structure_tests.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/checkpoint_root/tests/rollup_structure_tests.nr @@ -21,7 +21,7 @@ fn with_both_roots_left_is_first() { } } -#[test(should_fail_with = "Right rollup must not carry in_hash")] +#[test(should_fail_with = "Right rollup must not be a first block")] fn with_both_roots_right_is_first() { TestBuilder::new( BLOCK_ROOT_ROLLUP_VK_INDEX, @@ -32,7 +32,7 @@ fn with_both_roots_right_is_first() { .execute_with_mock_and_fail(); } -#[test(should_fail_with = "Right rollup must not carry in_hash")] +#[test(should_fail_with = "Right rollup must not be a first block")] fn with_both_first_roots() { TestBuilder::new( BLOCK_ROOT_FIRST_ROLLUP_VK_INDEX, @@ -43,7 +43,7 @@ fn with_both_first_roots() { .execute_with_mock_and_fail(); } -#[test(should_fail_with = "in_hash must be set via the first block root in the checkpoint")] +#[test(should_fail_with = "The first block of the checkpoint must be a first block root")] fn with_both_non_first_roots() { TestBuilder::new(BLOCK_ROOT_ROLLUP_VK_INDEX, 1, BLOCK_ROOT_ROLLUP_VK_INDEX, 1) .execute_with_mock_and_fail(); @@ -64,7 +64,7 @@ fn with_left_merge_and_right_root() { builder.assert_mock_called(mock); } -#[test(should_fail_with = "in_hash must be set via the first block root in the checkpoint")] +#[test(should_fail_with = "The first block of the checkpoint must be a first block root")] fn with_left_non_first_merge_and_right_root() { let mut builder = TestBuilder::new( // Left rollup is a merge that has 4 blocks. @@ -75,13 +75,13 @@ fn with_left_non_first_merge_and_right_root() { 1, ); - // The merge at the left has 0 in hash since it does not contain the first block root. - builder.left_rollup.in_hash = 0; + // The merge at the left is not a first block since it does not contain the first block root. + builder.left_rollup.is_first_block = false; builder.execute_with_mock_and_fail(); } -#[test(should_fail_with = "Right rollup must not carry in_hash")] +#[test(should_fail_with = "Right rollup must not be a first block")] fn with_left_non_first_merge_and_right_first_root() { let mut builder = TestBuilder::new( // Left rollup is a merge that has 4 blocks. @@ -92,8 +92,8 @@ fn with_left_non_first_merge_and_right_first_root() { 1, ); - // The merge at the left has 0 in hash since it does not contain the first block root. - builder.left_rollup.in_hash = 0; + // The merge at the left is not a first block since it does not contain the first block root. + builder.left_rollup.is_first_block = false; builder.execute_with_mock_and_fail(); } diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/inbox_rolling_hash.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/inbox_rolling_hash.nr new file mode 100644 index 000000000000..661f898f7fb3 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/inbox_rolling_hash.nr @@ -0,0 +1,94 @@ +use types::hash::accumulate_sha256; + +/// Extends the Inbox rolling sha256 chain by the first `num_leaves` of `leaves`, returning the new rolling hash. +/// +/// Each link is `h' = sha256ToField(h || leaf)` over the two 32-byte big-endian values, i.e. exactly one +/// `accumulate_sha256` step, matching the truncated-to-field sha256 the L1 `Inbox` accumulates and today's `inHash` +/// frontier tree uses at every node. The genesis rolling hash is zero. +/// +/// The function takes a `start` and returns an end with no assumption about chunk position, so it chains sequentially +/// across chunked circuits: a segment's start hash is the previous segment's end. Lanes beyond `num_leaves` are never +/// absorbed — the Inbox chain only ever sees real messages. +pub fn accumulate_inbox_rolling_hash( + start: Field, + leaves: [Field; N], + num_leaves: u32, +) -> Field { + assert(num_leaves <= N, "num_leaves is greater than the leaves array length"); + + let mut acc = start; + for i in 0..N { + if i < num_leaves { + acc = accumulate_sha256(acc, leaves[i]); + } + } + acc +} + +mod tests { + use super::accumulate_inbox_rolling_hash; + use types::{constants::INBOX_PARITY_SIZE_MEDIUM, hash::accumulate_sha256}; + + #[test] + fn empty_bundle_passes_start_through() { + assert_eq(accumulate_inbox_rolling_hash(0, [0; 8], 0), 0); + // A non-zero start with no leaves is returned unchanged (segment threading base case). + assert_eq(accumulate_inbox_rolling_hash(0x2a, [11, 22, 33], 0), 0x2a); + } + + #[test] + fn single_leaf_matches_reference() { + // Independent sha256 reference (see PR description): sha256ToField(0x00..00 || 0x00..0b), last byte dropped. + let expected = 0x00815fb1e9d2076ae5761439b6144ad11da69eb6c41ab2aca39e770407ad8d12; + assert_eq(accumulate_inbox_rolling_hash(0, [11, 0, 0, 0], 1), expected); + assert_eq(accumulate_sha256(0, 11), expected); + } + + #[test] + fn three_leaves_matches_reference() { + let expected = 0x0014cae968461979aab6d33266a2310ed234d3f6cf4472737c57551db07bd0da; + assert_eq(accumulate_inbox_rolling_hash(0, [11, 22, 33, 0, 0], 3), expected); + } + + #[test] + fn batch_matches_reference() { + // 256 leaves valued 1..=256 from a zero start. + let mut leaves = [0; INBOX_PARITY_SIZE_MEDIUM]; + for i in 0..INBOX_PARITY_SIZE_MEDIUM { + leaves[i] = (i + 1) as Field; + } + let expected = 0x00ea95b96f17b75be03525b35a2a1918b42f03ad8c00a437cf641751825f3992; + assert_eq(accumulate_inbox_rolling_hash(0, leaves, INBOX_PARITY_SIZE_MEDIUM), expected); + } + + #[test] + fn non_zero_start_matches_reference() { + let expected = 0x0054d96b8a074a5030a5838972d0a3c04ba47cf5956348c853e02e9566233f65; + assert_eq(accumulate_inbox_rolling_hash(0x2a, [7, 8], 2), expected); + } + + #[test] + fn chain_is_continuous_across_segments() { + // Chaining [7,8,9] from a start equals chaining [7] then [8,9] threaded by the intermediate hash. + let start = 0x2a; + let full = accumulate_inbox_rolling_hash(start, [7, 8, 9, 0, 0], 3); + + let mid = accumulate_inbox_rolling_hash(start, [7, 0], 1); + let split = accumulate_inbox_rolling_hash(mid, [8, 9], 2); + + assert_eq(full, split); + } + + #[test] + fn padding_lanes_are_not_absorbed() { + // A padded array with num_leaves set correctly matches the exact-length chain regardless of lane contents. + let padded = accumulate_inbox_rolling_hash(0, [11, 22, 999, 888], 2); + let exact = accumulate_inbox_rolling_hash(0, [11, 22], 2); + assert_eq(padded, exact); + } + + #[test(should_fail_with = "num_leaves is greater than the leaves array length")] + fn num_leaves_past_array_fails() { + let _ = accumulate_inbox_rolling_hash(0, [11, 22, 33], 4); + } +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/lib.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/lib.nr index af4d39d00c99..f6c5a2d30577 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/lib.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/lib.nr @@ -1,6 +1,7 @@ pub(crate) mod abis; pub(crate) mod tests; +pub mod inbox_rolling_hash; pub mod tx_base; pub mod tx_merge; pub mod block_root; diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/inbox_parity.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/inbox_parity.nr new file mode 100644 index 000000000000..83f99510b696 --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/inbox_parity.nr @@ -0,0 +1,63 @@ +use crate::{ + abis::{L1ToL2MessageSponge, ParityPublicInputs}, + inbox_rolling_hash::accumulate_inbox_rolling_hash, +}; +use types::utils::arrays::assert_trailing_zeros; + +/// Private inputs for the `InboxParity` circuit, generic over the message-bundle size `S`. +/// +/// One `InboxParity` proof is produced per checkpoint. The prover picks the smallest ladder size `S ∈ {64, 256, 1024}` +/// with `S >= num_msgs`, so a checkpoint with few messages proves a small circuit. +pub struct InboxParityPrivateInputs { + // The checkpoint's L1-to-L2 message leaves, padded with zeros beyond `num_msgs`. + pub(crate) msgs: [Field; S], + // Number of real (non-padding) messages in `msgs`. + pub(crate) num_msgs: u32, + // Rolling hash of the Inbox chain before this checkpoint's messages (the previous checkpoint's end value; genesis + // is zero). + pub(crate) start_rolling_hash: Field, + // Message-bundle sponge before this checkpoint's messages (empty at checkpoint start). + pub(crate) start_sponge: L1ToL2MessageSponge, + // The L1 `in_hash` (sha256 frontier root of this checkpoint's messages), passed through UNCONSTRAINED to the + // public inputs. See `ParityPublicInputs::in_hash`: the frontier tree is gone from this body, so the prover + // supplies the value and the circuit does not recompute or bind it to `msgs`. + pub(crate) in_hash: Field, + pub(crate) vk_tree_root: Field, + pub(crate) prover_id: Field, +} + +/// The Inbox Parity circuit recomputes, for one checkpoint, the Inbox rolling-hash chain over the checkpoint's real +/// L1-to-L2 messages and absorbs the same real messages into the message-bundle sponge. It replaces the parity base + +/// parity root family with a single variable-size proof per checkpoint. +/// +/// This circuit: +/// - Chains the `num_msgs` real messages into the rolling hash (two sha256 compressions per leaf) +/// - Absorbs the same real messages into the message sponge (real-count absorb; the checkpoint root asserts this +/// equals the sponge the block roots accumulate) +/// - Asserts the padding lanes past `num_msgs` are zero so they cannot silently enter either accumulator +/// - Passes `in_hash` through unconstrained (see `InboxParityPrivateInputs::in_hash`) +/// +/// The output feeds the Checkpoint Root circuits, which verify this proof against the `{64, 256, 1024}` VK ladder. +/// +/// VkIndex: INBOX_PARITY_{64,256,1024}_VK_INDEX +pub fn execute(inputs: InboxParityPrivateInputs) -> ParityPublicInputs { + // Guard the padding lanes so they can't silently enter either accumulator (`num_msgs <= S` is asserted here too). + assert_trailing_zeros(inputs.msgs, inputs.num_msgs); + + let end_rolling_hash = + accumulate_inbox_rolling_hash(inputs.start_rolling_hash, inputs.msgs, inputs.num_msgs); + + let mut end_sponge = inputs.start_sponge; + end_sponge.absorb(inputs.msgs, inputs.num_msgs); + + ParityPublicInputs { + in_hash: inputs.in_hash, + start_rolling_hash: inputs.start_rolling_hash, + end_rolling_hash, + start_sponge: inputs.start_sponge, + end_sponge, + num_msgs: inputs.num_msgs, + vk_tree_root: inputs.vk_tree_root, + prover_id: inputs.prover_id, + } +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/mod.nr index 668a2cb50cf5..3fed3a63fef6 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/mod.nr @@ -1,7 +1,5 @@ -pub mod parity_base; -pub mod parity_root; +pub mod inbox_parity; mod tests; pub use crate::abis::ParityPublicInputs; -pub use parity_base::ParityBasePrivateInputs; -pub use parity_root::ParityRootPrivateInputs; +pub use inbox_parity::InboxParityPrivateInputs; diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/parity_base.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/parity_base.nr deleted file mode 100644 index 4cc7451d0d34..000000000000 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/parity_base.nr +++ /dev/null @@ -1,34 +0,0 @@ -use crate::abis::ParityPublicInputs; -use types::{constants::NUM_MSGS_PER_BASE_PARITY, merkle_tree::MerkleTree}; - -pub struct ParityBasePrivateInputs { - pub(crate) msgs: [Field; NUM_MSGS_PER_BASE_PARITY], - pub(crate) vk_tree_root: Field, - pub(crate) prover_id: Field, -} - -/// The Parity Base circuit processes a batch of L1-to-L2 messages and computes their merkle roots. -/// It is the first step in converting L1 messages from SHA256 format (used on L1) to Poseidon format -/// (used in Aztec's state trees). -/// -/// This circuit: -/// - Takes a fixed batch of L1-to-L2 messages as input -/// - Computes a SHA256 merkle tree root over the messages (for verification on L1) -/// - Computes a Poseidon merkle tree root over the same messages (for L2 state tree insertion) -/// - Outputs both roots along with the vk_tree_root for consistency verification -/// -/// The output feeds into the Parity Root circuit, which aggregates multiple Parity Base proofs to form the complete -/// L1-to-L2 message subtree for a checkpoint. -/// -/// VkIndex: PARITY_BASE_VK_INDEX -pub fn execute(inputs: ParityBasePrivateInputs) -> ParityPublicInputs { - let sha_tree = MerkleTree::new_sha(inputs.msgs); - let poseidon_tree = MerkleTree::new(inputs.msgs); - - ParityPublicInputs { - sha_root: sha_tree.get_root(), - converted_root: poseidon_tree.get_root(), - vk_tree_root: inputs.vk_tree_root, - prover_id: inputs.prover_id, - } -} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/parity_root.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/parity_root.nr deleted file mode 100644 index 62bdda658e0b..000000000000 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/parity_root.nr +++ /dev/null @@ -1,103 +0,0 @@ -use crate::abis::ParityPublicInputs; -use types::{ - constants::{NUM_BASE_PARITY_PER_ROOT_PARITY, PARITY_BASE_VK_INDEX}, - merkle_tree::MerkleTree, - proof::proof_data::UltraHonkProofData, -}; - -pub type ParityBaseProofData = UltraHonkProofData; - -pub struct ParityRootPrivateInputs { - pub(crate) children: [ParityBaseProofData; NUM_BASE_PARITY_PER_ROOT_PARITY], -} - -/// The Parity Root circuit aggregates multiple Parity Base proofs to form the complete L1-to-L2 message subtree for a -/// checkpoint. It combines the merkle roots from child circuits into final roots. -/// -/// This circuit: -/// - Verifies proofs from multiple Parity Base circuits (the children) -/// - Validates that all children use the same vk_tree_root -/// - Validates that all children use the same prover_id -/// - Validates that all children use the same verification key (consistent vk hash, index, and path) -/// - Validates the verification key exists in the vk tree -/// - Computes the final SHA256 merkle root by merging the children's SHA roots -/// - Computes the final Poseidon merkle root by merging the children's converted roots -/// -/// The output feeds into the Block Root First circuits, where the `sha_root` is used to compute the `in_hash` for -/// verification against the value on L1, and the `converted_root` is inserted into the L1-to-L2 message tree to be -/// consumed by the app circuits. -/// -/// VkIndex: PARITY_ROOT_VK_INDEX -pub fn execute(inputs: ParityRootPrivateInputs) -> ParityPublicInputs { - let vk_tree_root = inputs.children[0].public_inputs.vk_tree_root; - for i in 1..NUM_BASE_PARITY_PER_ROOT_PARITY { - assert_eq( - inputs.children[i].public_inputs.vk_tree_root, - vk_tree_root, - "Inconsistent vk tree roots across parity base circuits", - ); - } - - let prover_id = inputs.children[0].public_inputs.prover_id; - for i in 1..NUM_BASE_PARITY_PER_ROOT_PARITY { - assert_eq( - inputs.children[i].public_inputs.prover_id, - prover_id, - "Inconsistent prover ids across parity base circuits", - ); - } - - verify_child_proofs(inputs); - - let mut sha_roots = [0; NUM_BASE_PARITY_PER_ROOT_PARITY]; - let mut converted_roots = [0; NUM_BASE_PARITY_PER_ROOT_PARITY]; - for i in 0..NUM_BASE_PARITY_PER_ROOT_PARITY { - sha_roots[i] = inputs.children[i].public_inputs.sha_root; - converted_roots[i] = inputs.children[i].public_inputs.converted_root; - } - - let sha_tree = MerkleTree::new_sha(sha_roots); - let poseidon_tree = MerkleTree::new(converted_roots); - - ParityPublicInputs { - sha_root: sha_tree.get_root(), - converted_root: poseidon_tree.get_root(), - vk_tree_root, - prover_id, - } -} - -fn verify_child_proofs(inputs: ParityRootPrivateInputs) { - let vk_data = inputs.children[0].vk_data; - let vk_tree_root = inputs.children[0].public_inputs.vk_tree_root; - - inputs.children[0].verify_proof(); - - for i in 1..NUM_BASE_PARITY_PER_ROOT_PARITY { - inputs.children[i].verify_proof(); - - // No need to check `vk_data.vk.key` here, as it's verified in bb that it produces the given hash (`vk_data.vk.hash`). - // So we can ensure that all the keys are the same by asserting that their hashes are equal across all children. - assert_eq( - inputs.children[i].vk_data.vk.hash, - vk_data.vk.hash, - "Inconsistent vk hashes across parity base circuits", - ); - assert_eq( - inputs.children[i].vk_data.leaf_index, - vk_data.leaf_index, - "Inconsistent vk indices across parity base circuits", - ); - assert_eq( - inputs.children[i].vk_data.sibling_path, - vk_data.sibling_path, - "Inconsistent vk paths across parity base circuits", - ); - } - - assert_eq(vk_data.leaf_index, PARITY_BASE_VK_INDEX, "Incorrect vk index for parity base"); - - // Since the vk hashes and paths have been checked to be consistent across all children, - // it's sufficient to validate that one of them exists in the vk tree. - vk_data.validate_in_vk_tree(vk_tree_root); -} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/inbox_parity_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/inbox_parity_tests.nr new file mode 100644 index 000000000000..73f4565d9c6a --- /dev/null +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/inbox_parity_tests.nr @@ -0,0 +1,135 @@ +use crate::{ + abis::L1ToL2MessageSponge, + inbox_rolling_hash::accumulate_inbox_rolling_hash, + parity::inbox_parity::{self, InboxParityPrivateInputs}, +}; +use types::traits::Empty; + +global S: u32 = 64; + +#[test] +fn public_inputs_match_expected() { + let mut msgs = [0; S]; + for i in 0..S { + msgs[i] = i as Field; + } + let private_inputs = InboxParityPrivateInputs { + msgs, + num_msgs: S, + start_rolling_hash: 0, + start_sponge: L1ToL2MessageSponge::empty(), + in_hash: 0x1234, + vk_tree_root: 42, + prover_id: 7, + }; + let public_inputs = inbox_parity::execute(private_inputs); + + // `in_hash` is echoed through unconstrained. + assert_eq(public_inputs.in_hash, 0x1234); + assert_eq(public_inputs.vk_tree_root, 42); + assert_eq(public_inputs.prover_id, 7); + + // The rolling hash chains all real messages on top of the start value; the circuit echoes back its start/count. + assert_eq(public_inputs.start_rolling_hash, 0); + assert_eq(public_inputs.num_msgs, S); + assert_eq(public_inputs.end_rolling_hash, accumulate_inbox_rolling_hash(0, msgs, S)); + + // The sponge absorbs exactly the real messages (real-count), threading the start. + assert_eq(public_inputs.start_sponge, L1ToL2MessageSponge::empty()); + let mut expected_end_sponge = L1ToL2MessageSponge::empty(); + expected_end_sponge.absorb(msgs, S); + assert_eq(public_inputs.end_sponge, expected_end_sponge); +} + +#[test] +fn rolling_hash_and_sponge_ignore_padding_and_thread_start() { + // Only the first three lanes are real; the rest are zero padding. + let mut msgs = [0; S]; + msgs[0] = 11; + msgs[1] = 22; + msgs[2] = 33; + + let start = 0x2a; + let mut start_sponge = L1ToL2MessageSponge::new(); + start_sponge.absorb([7, 8], 2); + let private_inputs = InboxParityPrivateInputs { + msgs, + num_msgs: 3, + start_rolling_hash: start, + start_sponge, + in_hash: 0, + vk_tree_root: 42, + prover_id: 7, + }; + let public_inputs = inbox_parity::execute(private_inputs); + + assert_eq(public_inputs.start_rolling_hash, start); + assert_eq(public_inputs.num_msgs, 3); + assert_eq(public_inputs.end_rolling_hash, accumulate_inbox_rolling_hash(start, [11, 22, 33], 3)); + + // Both the rolling hash and the sponge see only the three real leaves (real-count absorb). + assert_eq(public_inputs.start_sponge, start_sponge); + let mut expected_end_sponge = start_sponge; + expected_end_sponge.absorb([11, 22, 33], 3); + assert_eq(public_inputs.end_sponge, expected_end_sponge); +} + +#[test] +fn sponge_matches_block_root_real_count_absorb() { + // The checkpoint root asserts InboxParity's end sponge equals the sponge the block roots accumulate. The block + // roots absorb the real messages (real-count) out of their padded bundle, so InboxParity must reach the same + // state absorbing the same real prefix out of a differently-sized (here smaller) array. + let mut msgs = [0; S]; + msgs[0] = 101; + msgs[1] = 202; + + let private_inputs = InboxParityPrivateInputs { + msgs, + num_msgs: 2, + start_rolling_hash: 0, + start_sponge: L1ToL2MessageSponge::empty(), + in_hash: 0, + vk_tree_root: 42, + prover_id: 7, + }; + let public_inputs = inbox_parity::execute(private_inputs); + + // A block root absorbing the same two real leaves out of its 1024-wide bundle reaches the same sponge. + let mut block_sponge = L1ToL2MessageSponge::empty(); + block_sponge.absorb([101, 202, 0, 0, 0], 2); + assert_eq(public_inputs.end_sponge, block_sponge); +} + +#[test(should_fail_with = "Found non-zero field after breakpoint")] +fn non_zero_padding_lane_fails() { + // Claim two real messages but leave a non-zero value in a padding lane. + let mut msgs = [0; S]; + msgs[0] = 11; + msgs[1] = 22; + msgs[5] = 999; + + let private_inputs = InboxParityPrivateInputs { + msgs, + num_msgs: 2, + start_rolling_hash: 0, + start_sponge: L1ToL2MessageSponge::empty(), + in_hash: 0, + vk_tree_root: 42, + prover_id: 7, + }; + let _ = inbox_parity::execute(private_inputs); +} + +#[test(should_fail_with = "in_len is greater than the input array len")] +fn num_msgs_greater_than_size_fails() { + let private_inputs = InboxParityPrivateInputs { + msgs: [0; S], + num_msgs: S + 1, + start_rolling_hash: 0, + start_sponge: L1ToL2MessageSponge::empty(), + in_hash: 0, + vk_tree_root: 42, + prover_id: 7, + }; + let _ = inbox_parity::execute(private_inputs); +} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/mod.nr index 069b1e4a3565..417040122994 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/mod.nr @@ -1,2 +1 @@ -mod parity_base_tests; -mod parity_root_tests; +mod inbox_parity_tests; diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/parity_base_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/parity_base_tests.nr deleted file mode 100644 index 5dc2071f28c4..000000000000 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/parity_base_tests.nr +++ /dev/null @@ -1,21 +0,0 @@ -use crate::parity::parity_base::{self, ParityBasePrivateInputs}; -use types::constants::NUM_MSGS_PER_BASE_PARITY; - -#[test] -fn public_inputs_match_expected() { - let mut msgs = [0; NUM_MSGS_PER_BASE_PARITY]; - for i in 0..NUM_MSGS_PER_BASE_PARITY { - msgs[i] = i as Field; - } - let private_inputs = ParityBasePrivateInputs { msgs, vk_tree_root: 42, prover_id: 7 }; - let public_inputs = parity_base::execute(private_inputs); - - let expected_sha_root = 0x279d4d4dd5bcb9b1a4e742640588b917102f9f8bc97a6c95706ca4e7a8a76b; - let expected_converted_root = - 0x24425e91123ffa26018e970b92316101d503c5937f145d69569ac907d0bd36ec; - - assert_eq(public_inputs.sha_root, expected_sha_root); - assert_eq(public_inputs.converted_root, expected_converted_root); - assert_eq(public_inputs.vk_tree_root, 42); - assert_eq(public_inputs.prover_id, 7); -} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/parity_root_tests.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/parity_root_tests.nr deleted file mode 100644 index beb9ef9f2ab8..000000000000 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/parity/tests/parity_root_tests.nr +++ /dev/null @@ -1,144 +0,0 @@ -use crate::{ - abis::ParityPublicInputs, - parity::parity_root::{self, ParityBaseProofData, ParityRootPrivateInputs}, -}; -use protocol_test_utils::{fixtures::vk_tree::{get_vk_data, vk_tree_root}, pad_end}; -use types::{ - constants::{ - NUM_BASE_PARITY_PER_ROOT_PARITY, PARITY_BASE_VK_INDEX, PARITY_ROOT_VK_INDEX, - ULTRA_VK_LENGTH_IN_FIELDS, - }, - proof::{proof_data::ProofData, vk_data::VkData}, -}; - -struct TestBuilder { - children: [ParityBaseProofData; NUM_BASE_PARITY_PER_ROOT_PARITY], -} - -impl TestBuilder { - pub fn new() -> Self { - let vk_data = get_vk_data(PARITY_BASE_VK_INDEX); - - // 31 byte test SHA roots - let children_sha_roots = [ - 0xb3a3fc1968999f2c2d798b900bdf0de41311be2a4d20496a7e792a521fc8ab, - 0x43f78e0ebc9633ce336a8c086064d898c32fb5d7d6011f5427459c0b8d14e9, - 0x024259b6404280addcc9319bc5a32c9a5d56af5c93b2f941fa326064fbe963, - 0x53042d820859d80c474d4694e03778f8dc0ac88fc1c3a97b4369c1096e904a, - ]; - - let children = children_sha_roots.map(|sha_root| Self::make_proof_data(sha_root, vk_data)); - - Self { children } - } - - fn make_proof_data( - sha_root: Field, - vk_data: VkData, - ) -> ParityBaseProofData { - let public_inputs = - ParityPublicInputs { sha_root, converted_root: 0, vk_tree_root, prover_id: 42 }; - - let value_offset = sha_root / 2; - ProofData { - public_inputs, - proof: pad_end( - [value_offset + 450343, value_offset + 27394, value_offset + 8003179], - ), - vk_data, - } - } - - pub fn execute(self) -> ParityPublicInputs { - let private_inputs = ParityRootPrivateInputs { children: self.children }; - parity_root::execute(private_inputs) - } -} - -#[test] -fn public_inputs_match_expected() { - let public_inputs = TestBuilder::new().execute(); - - let expected_sha_root = 0xa0c56543aa73140e5ca27231eee3107bd4e11d62164feb411d77c9d9b2da47; - let expected_converted_root = - 0x14e4b977b2203b70e6ee1c2456eb7114d090fe4b907f631eecd0919fed432e7d; - - assert_eq(public_inputs.sha_root, expected_sha_root); - assert_eq(public_inputs.converted_root, expected_converted_root); - assert_eq(public_inputs.vk_tree_root, vk_tree_root); - assert_eq(public_inputs.prover_id, 42); -} - -#[test(should_fail_with = "Inconsistent vk tree roots across parity base circuits")] -fn inconsistent_vk_tree_root() { - let mut builder = TestBuilder::new(); - - // Tweak the vk tree root of the second child. - builder.children[1].public_inputs.vk_tree_root += 1; - - let _ = builder.execute(); -} - -#[test(should_fail_with = "Membership check failed: vk hash not found in vk tree")] -fn incorrect_vk_tree_root() { - let mut builder = TestBuilder::new(); - - // Change the vk tree root of all children. - for i in 0..NUM_BASE_PARITY_PER_ROOT_PARITY { - builder.children[i].public_inputs.vk_tree_root += 1; - } - - let _ = builder.execute(); -} - -#[test(should_fail_with = "Inconsistent vk hashes across parity base circuits")] -fn inconsistent_vk_hashes() { - let mut builder = TestBuilder::new(); - - // Tweak the vk hash of the third child. - builder.children[2].vk_data.vk.hash += 1; - - let _ = builder.execute(); -} - -#[test(should_fail_with = "Inconsistent vk indices across parity base circuits")] -fn inconsistent_vk_indices() { - let mut builder = TestBuilder::new(); - - // Change the vk leaf index of the last child to be the root parity index. - builder.children[3].vk_data.leaf_index = PARITY_ROOT_VK_INDEX; - - let _ = builder.execute(); -} - -#[test(should_fail_with = "Inconsistent vk paths across parity base circuits")] -fn inconsistent_vk_paths() { - let mut builder = TestBuilder::new(); - - // Tweak the vk path of the first child. - builder.children[0].vk_data.sibling_path[0] += 1; - - let _ = builder.execute(); -} - -#[test(should_fail_with = "Incorrect vk index for parity base")] -fn incorrect_vk_index() { - let mut builder = TestBuilder::new(); - - // Change the vk leaf index of all children to be the root parity index. - for i in 0..NUM_BASE_PARITY_PER_ROOT_PARITY { - builder.children[i].vk_data.leaf_index = PARITY_ROOT_VK_INDEX; - } - - let _ = builder.execute(); -} - -#[test(should_fail_with = "Inconsistent prover ids across parity base circuits")] -fn inconsistent_prover_ids() { - let mut builder = TestBuilder::new(); - - // Tweak the prover_id of the second child. - builder.children[1].public_inputs.prover_id += 1; - - let _ = builder.execute(); -} diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/root/root_rollup.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/root/root_rollup.nr index 8ce096c85a55..e816ba911dfb 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/root/root_rollup.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/root/root_rollup.nr @@ -119,6 +119,8 @@ pub fn execute(inputs: RootRollupPrivateInputs) -> RootRollupPublicInputs { previous_archive_root: merged.previous_archive.root, new_archive_root: merged.new_archive.root, out_hash: merged.new_out_hash.root, + previous_inbox_rolling_hash: merged.start_inbox_rolling_hash, + end_inbox_rolling_hash: merged.end_inbox_rolling_hash, checkpoint_header_hashes: merged.checkpoint_header_hashes, fees: merged.fees, constants: merged.constants, diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/root/tests/mod.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/root/tests/mod.nr index be50184fd264..a306decbdb3b 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/root/tests/mod.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/root/tests/mod.nr @@ -122,6 +122,10 @@ impl TestBuilder { assert_eq(pi.out_hash, right.new_out_hash.root); + // The epoch exposes the first checkpoint's chain start and the last checkpoint's chain end as a pass-through. + assert_eq(pi.previous_inbox_rolling_hash, left.start_inbox_rolling_hash); + assert_eq(pi.end_inbox_rolling_hash, right.end_inbox_rolling_hash); + let mut expected_header_hashes = [0; MAX_CHECKPOINTS_PER_EPOCH]; let mut expected_fees = [FeeRecipient::empty(); MAX_CHECKPOINTS_PER_EPOCH]; for i in 0..self.num_left_checkpoints as u32 { @@ -153,6 +157,9 @@ impl TestBuilder { assert_eq(pi.out_hash, left.new_out_hash.root); + assert_eq(pi.previous_inbox_rolling_hash, left.start_inbox_rolling_hash); + assert_eq(pi.end_inbox_rolling_hash, left.end_inbox_rolling_hash); + assert_eq(pi.checkpoint_header_hashes, left.checkpoint_header_hashes); assert_eq(pi.fees, left.fees); diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/tests/rollup_fixture_builder.nr b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/tests/rollup_fixture_builder.nr index 50ac6d8f71fe..129c55ae4061 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/tests/rollup_fixture_builder.nr +++ b/noir-projects/noir-protocol-circuits/crates/rollup-lib/src/tests/rollup_fixture_builder.nr @@ -1,5 +1,6 @@ use crate::abis::{ - BlockRollupPublicInputs, CheckpointRollupPublicInputs, ParityPublicInputs, TxRollupPublicInputs, + BlockRollupPublicInputs, CheckpointRollupPublicInputs, L1ToL2MessageSponge, ParityPublicInputs, + TxRollupPublicInputs, }; use bigcurve::BigCurve; use bignum::BigNum; @@ -23,14 +24,22 @@ use types::{ constants::{ ARCHIVE_HEIGHT, BLOBS_PER_CHECKPOINT, DOM_SEP__BLOB_GAMMA_FINAL, EMPTY_EPOCH_OUT_HASH, L1_TO_L2_MSG_SUBTREE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT, MAX_CHECKPOINTS_PER_EPOCH, - OUT_HASH_TREE_HEIGHT, OUT_HASH_TREE_LEAF_COUNT, + MAX_L1_TO_L2_MSGS_PER_BLOCK, OUT_HASH_TREE_HEIGHT, OUT_HASH_TREE_LEAF_COUNT, }, hash::{poseidon2_hash, poseidon2_hash_with_separator}, - merkle_tree::{compute_empty_tree_root, MerkleTree, test_utils::SingleSubtreeMerkleTree}, + merkle_tree::{ + append_only_tree::append_leaves_to_snapshot, compute_empty_tree_root, MerkleTree, + test_utils::SingleSubtreeMerkleTree, + }, proof::proof_data::{AvmV2ProofData, ProofData}, traits::{Deserialize, Empty, Hash}, }; +// The fixture pre-fills l1-to-l2 leaves into a single subtree of 2^3 = 8 leaves, which bounds how far into the tree a +// block's bundle can be made to start. The bundle append itself is not aligned to that subtree. +global PRE_EXISTING_L1_TO_L2_SUBTREE_HEIGHT: u32 = 3; +global PRE_EXISTING_L1_TO_L2_LEAF_COUNT: u32 = 8; + pub struct RollupFixtureBuilder { // Epoch constants. pub chain_id: Field, @@ -176,6 +185,61 @@ impl RollupFixtureBuilder { (previous_snapshot, sibling_path_for_insertion, new_snapshot) } + /// Builds a per-block L1-to-L2 message bundle appended to an empty tree, returning + /// `(previous_snapshot, leaves, frontier_hint, new_snapshot)`. The resulting `new_snapshot` is exactly what the + /// block root circuit recomputes from the same inputs. + pub fn build_l1_to_l2_message_bundle( + self, + num_msgs: u32, + ) -> (AppendOnlyTreeSnapshot, [Field; MAX_L1_TO_L2_MSGS_PER_BLOCK], [Field; L1_TO_L2_MSG_TREE_HEIGHT], AppendOnlyTreeSnapshot) { + self.build_l1_to_l2_message_bundle_at_index(num_msgs, 0) + } + + /// Same as `build_l1_to_l2_message_bundle`, but appending into a tree that already holds `start_index` leaves — + /// the compact, unaligned append every block after the very first one performs. The pre-existing leaves sit in a + /// single subtree of `PRE_EXISTING_L1_TO_L2_LEAF_COUNT` leaves, so `start_index` must stay below that. The frontier + /// hint is the tree's sibling path at `start_index`, which is how a tree database answers for it: the pending left + /// sibling at every level where the index is a right child, and the zero-subtree root everywhere else. + pub fn build_l1_to_l2_message_bundle_at_index( + _self: Self, + num_msgs: u32, + start_index: u32, + ) -> (AppendOnlyTreeSnapshot, [Field; MAX_L1_TO_L2_MSGS_PER_BLOCK], [Field; L1_TO_L2_MSG_TREE_HEIGHT], AppendOnlyTreeSnapshot) { + assert( + start_index < PRE_EXISTING_L1_TO_L2_LEAF_COUNT, + "The fixture cannot pre-fill that many l1-to-l2 leaves", + ); + + let mut pre_existing = [0; PRE_EXISTING_L1_TO_L2_LEAF_COUNT]; + for i in 0..PRE_EXISTING_L1_TO_L2_LEAF_COUNT { + if i < start_index { + pre_existing[i] = (i + 1) as Field * 7; + } + } + let tree = SingleSubtreeMerkleTree::::new( + pre_existing, + ); + + let mut leaves = [0; MAX_L1_TO_L2_MSGS_PER_BLOCK]; + for i in 0..MAX_L1_TO_L2_MSGS_PER_BLOCK { + if i < num_msgs { + leaves[i] = (i + 1) as Field * 100; + } + } + let previous = AppendOnlyTreeSnapshot { + root: tree.get_root(), + next_available_leaf_index: start_index as Field, + }; + let frontier_hint = tree.get_sibling_path(start_index as Field); + let new = append_leaves_to_snapshot::( + previous, + leaves, + num_msgs, + frontier_hint, + ); + (previous, leaves, frontier_hint, new) + } + pub fn build_out_hash_tree_for_insertion( self, slot_number: Field, @@ -315,11 +379,19 @@ impl RollupFixtureBuilder { ) -> BlockRollupPublicInputs { let slot_number = self.start_slot_number; - let in_hash = if start_block_number == self.start_block_number { - self.get_in_hash(slot_number) + // Only the first block of a checkpoint (the leftmost leaf) carries `is_first_block`. + let is_first_block = start_block_number == self.start_block_number; + + // The message sponge threads across the checkpoint's blocks. The leftmost block starts from empty; every block + // ends at the checkpoint's accumulated sponge (in the fixture, only the first block absorbs, so the sponge stays + // constant for the non-first blocks). This matches the transitional wiring where the first block carries the + // whole checkpoint's bundle. + let start_msg_sponge = if is_first_block { + L1ToL2MessageSponge::empty() } else { - 0 + self.get_msg_sponge(slot_number) }; + let end_msg_sponge = self.get_msg_sponge(slot_number); BlockRollupPublicInputs { constants: self.get_checkpoint_constant_data(slot_number), @@ -331,7 +403,9 @@ impl RollupFixtureBuilder { end_sponge_blob: self.get_sponge_blob(end_block_number), timestamp: self.get_timestamp(slot_number), block_headers_hash: self.get_block_headers_hash(end_block_number), - in_hash, + is_first_block, + start_msg_sponge, + end_msg_sponge, out_hash: self.get_out_hash(end_block_number), accumulated_fees: self.get_fee(end_block_number), accumulated_mana_used: self.get_mana_used(end_block_number), @@ -371,6 +445,10 @@ impl RollupFixtureBuilder { checkpoint_header_hashes, previous_out_hash: self.get_out_hash_snapshot(start_checkpoint_index), new_out_hash: self.get_out_hash_snapshot(end_checkpoint_index + 1), + // The chain spans this checkpoint range; consecutive checkpoints chain because each range's end + // (`get_inbox_rolling_hash(end_slot + 1)`) equals the next range's start (`get_inbox_rolling_hash(start_slot)`). + start_inbox_rolling_hash: self.get_inbox_rolling_hash(start_slot_number), + end_inbox_rolling_hash: self.get_inbox_rolling_hash(end_slot_number + 1), fees, start_blob_accumulator: self.get_blob_accumulator(start_slot_number - 1), end_blob_accumulator: self.get_blob_accumulator(end_slot_number), @@ -380,13 +458,27 @@ impl RollupFixtureBuilder { pub fn get_parity_public_inputs(self, slot_number: Field) -> ParityPublicInputs { ParityPublicInputs { - sha_root: slot_number * 85831493, - converted_root: self.get_l1_to_l2_message_subtree_root(slot_number), + in_hash: slot_number * 85831493, + start_rolling_hash: self.get_inbox_rolling_hash(slot_number), + end_rolling_hash: self.get_inbox_rolling_hash(slot_number + 1), + // The message sponge resets per checkpoint, so it starts empty and ends at the checkpoint's accumulated + // sponge — the same value the block roots reach across the checkpoint. + start_sponge: L1ToL2MessageSponge::empty(), + end_sponge: self.get_msg_sponge(slot_number), + num_msgs: 7, vk_tree_root: self.vk_tree_root, prover_id: self.prover_id, } } + /// Deterministic non-empty message sponge for a checkpoint, shared by that checkpoint's block roots (as their + /// end sponge) and its parity root (as its end sponge), so the checkpoint root's equality check passes. + pub fn get_msg_sponge(_self: Self, slot_number: Field) -> L1ToL2MessageSponge { + let mut sponge = L1ToL2MessageSponge::new(); + sponge.absorb([slot_number, slot_number * 7, slot_number * 13], 3); + sponge + } + pub fn get_sponge_blob(self, block_number: u32) -> SpongeBlob { let mut sponge: SpongeBlob = self.make_fixture(self.start_slot_number, block_number, 661); sponge.sponge.cache_size = 0; @@ -455,8 +547,8 @@ impl RollupFixtureBuilder { tx_or_block_or_slot_number as Field * 60415 } - fn get_in_hash(_self: Self, slot_number: Field) -> Field { - slot_number * 94297 + fn get_inbox_rolling_hash(_self: Self, slot_number: Field) -> Field { + slot_number * 917231 } fn get_timestamp(_self: Self, slot_number: Field) -> u64 { diff --git a/noir-projects/noir-protocol-circuits/crates/rollup-root/Prover.toml b/noir-projects/noir-protocol-circuits/crates/rollup-root/Prover.toml index 9f03a7f168e9..6ac5fe496ee7 100644 --- a/noir-projects/noir-protocol-circuits/crates/rollup-root/Prover.toml +++ b/noir-projects/noir-protocol-circuits/crates/rollup-root/Prover.toml @@ -483,11 +483,13 @@ proof = [ ] [inputs.previous_rollups.public_inputs] + start_inbox_rolling_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" + end_inbox_rolling_hash = "0x005b0c15d0f641e148adfec120a12eadbf8343e009d350aa593b6d78dbae9568" checkpoint_header_hashes = [ - "0x003f28245501cd83312b059b7469c9efcbd17cdf1b87748a6684380140e8b8f4", - "0x004395c583aa5d8b61d95de30020015595c6ff15a98a908376053c285e760047", - "0x001610d9516c5c3da43228cf8c78b4f8b0fbc41ac4fb52e8c263f5389f0c39c2", - "0x00cc4a04e2f982d4a235549d9cea86e657f0f84a2624baed667bc007ac6adbbf", + "0x00421218fb6353976d02c7d0a9a9b9ddea4174b055a3dbab1a9b3aab26a3ad4c", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -519,51 +521,51 @@ proof = [ ] [inputs.previous_rollups.public_inputs.constants] - chain_id = "0x0000000000000000000000000000000000000000000000000000000000007a69" - version = "0x000000000000000000000000000000000000000000000000000000005fe47cc3" - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - protocol_contracts_hash = "0x080e3881bdd4a4e78d52691e5543b50cf820f51baf52af42d7b58c9e15f96ec7" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" + chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + version = "0x0000000000000000000000000000000000000000000000000000000000000000" + vk_tree_root = "0x21cd94941458effa5bf748eb3839418d3deb6bdcd2c04148ca733561265326a5" + protocol_contracts_hash = "0x0a1f22b72996215e178699fff463a6ca5e3c7d5ffe66e183490eb766ec1c83ae" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.previous_archive] - root = "0x1842a814b068f699565f4df77ab9139f1cfab687ef959bf92ba0bb3adf93d8dd" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000009" + root = "0x0fb2945d3438d906d88a216364dbfe9760e96001343468610e01d18182d493d0" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [inputs.previous_rollups.public_inputs.new_archive] - root = "0x02b768bc715afcefe7acc2a4394dc1ec3d36e9051f52662c42c795597ad03956" - next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000d" + root = "0x046fb3e3937d8fe32eabae9d4658ef26f142bff7471c22d38f0022dc4701e96f" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000002" [inputs.previous_rollups.public_inputs.previous_out_hash] root = "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093" next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.new_out_hash] - root = "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000004" + root = "0x00aab5a9def4ce98b37101d06c1371e6978c474b666624b56da1ebeec25ba39d" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000001" [[inputs.previous_rollups.public_inputs.fees]] - value = "0x00000000000000000000000000000000000000000000000000198e45581dc500" + value = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.fees.recipient] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [[inputs.previous_rollups.public_inputs.fees]] - value = "0x00000000000000000000000000000000000000000000000000030e6f24b2fa80" + value = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.fees.recipient] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [[inputs.previous_rollups.public_inputs.fees]] - value = "0x00000000000000000000000000000000000000000000000000028969d4e88180" + value = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.fees.recipient] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [[inputs.previous_rollups.public_inputs.fees]] - value = "0x0000000000000000000000000000000000000000000000000002c99033813280" + value = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.fees.recipient] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [[inputs.previous_rollups.public_inputs.fees]] value = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -772,15 +774,15 @@ proof = [ ] [inputs.previous_rollups.public_inputs.end_blob_accumulator] - blob_commitments_hash_acc = "0x003c3d7634e4804fa2d1579984557d5e0f193db092992632750e0f02435c536e" - z_acc = "0x2e5590725ce897557051bcd8e235179ca85612f775e25899d41e2e6d429bab8f" - gamma_acc = "0x1a92da981183c7c99558cbbf36266f907c24981e57e22325cd913d6c0b511f0c" + blob_commitments_hash_acc = "0x008e930e5cd390434cd51d3c5334630426f265cb4b9ef8e13ae57bbef4d29e7f" + z_acc = "0x058efcffe9a6e9bad4fa111125c6c551bc591763ec8f82f544b00c121ed96772" + gamma_acc = "0x2dc3d4ad1a3fa08361aeca4de87afa4495661411a71bbd6547cc06a09854cb71" [inputs.previous_rollups.public_inputs.end_blob_accumulator.y_acc] limbs = [ - "0x51460e3323b2335762b279af363d8f", - "0xfb02d1de4f7cbf4de93446d5162177", - "0x64ca" + "0x0e3a533e5cc1831cd94ebe556eaa6b", + "0xd36dd1481df9788d7a4bf66c73913f", + "0x381c" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc] @@ -788,168 +790,168 @@ proof = [ [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc.x] limbs = [ - "0xe30b704d93a13e80d6b61851ffbb42", - "0xa6582dfbfe7c7fb2e4cb46ca26a4a9", - "0x58d8f47578a73f78ec55404027113b", - "0x088313" + "0x29014e784075cc2bdcffcdd1547f96", + "0xfa8fe87a202189634fbfddc1f2671b", + "0x4d6c91edb591280465dd2295f317c2", + "0x016442" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc.y] limbs = [ - "0xac35297801db6e89bc7c01cccf1c2c", - "0x5a8cdb9c6da878c061855cde01bada", - "0xf8ade47e6b400bf343963bce4206ac", - "0x02c72c" + "0x098aee9c7644342f665ea25ee6b704", + "0x292e462582e51ac0263e55ee43d2f8", + "0x1edcc6843e97b577e45748f9acd815", + "0x0f22a8" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.gamma_pow_acc] limbs = [ - "0xf3d1444be1d67a5ae57a7a5347f063", - "0xd40b5f08dc03ca05b5c582e87600d8", - "0x11f8" + "0x5b6f7f97684d6dbb89cf54400c3f78", + "0x2f1bcc10ffd47f0441cf0eb6b6560b", + "0x1b37" ] [inputs.previous_rollups.public_inputs.final_blob_challenges] - z = "0x1fdc12adc29013642cd3e65ed4fe6257a51f0de3dbf9aab308d2eb764d2e2a6c" + z = "0x058efcffe9a6e9bad4fa111125c6c551bc591763ec8f82f544b00c121ed96772" [inputs.previous_rollups.public_inputs.final_blob_challenges.gamma] limbs = [ - "0x3091f45075ebc6c0e8bd0d0b55148a", - "0xba36f4511ca8e170b8a14a64a7418f", - "0x070d" + "0x5b6f7f97684d6dbb89cf54400c3f78", + "0x2f1bcc10ffd47f0441cf0eb6b6560b", + "0x1b37" ] [inputs.previous_rollups.vk_data] - leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000013" + leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000011" sibling_path = [ - "0x1e7976567fc760772e92450d8ac6f02ef47edb23baa7459dc33c0ceb6c88497d", - "0x23545acba1dbc9308d912f371ee6d2f31ab1da4eccf3d019473d8ab7205adf27", - "0x035c573a1f2634405482213a2b805e186d6b81073e2b7a5bd3f64c2e4e8bc21e", - "0x033c4d295fe10d44c10ab7dd6b98731454b30ab8a3b175477338750c07bc4023", - "0x234c347546637311dad66534e5274a6a5db5da51b51baab040dac88807024ce5", - "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" + "0x0c10eb598741660f2160b4a6fe77191ad0c218b3a5f0ec4b8ebfecffaec4e4b9", + "0x121157fe0e38fc9db652bd52835686237090ef182f269df6fe777c5e5fd48aad", + "0x2e786d2377d9994a6dab998e113d87924b5b55a476ff385d0c66bcbb91158c60", + "0x20738d93e695096c6290e7c275252b87c3fc8a419bd4d9991368484bcbd446a7", + "0x2ea23c9cbeafe466f3725ea750741efad48745849cf61628cb3cd0e6156c6246", + "0x187a7b8872d1297bc15f7171f32c36e5e60b53c4145ef62b1899c04fd7220fdf", + "0x2ccaede67145021b6b586f45936dfbdacb151c3e362621c3598ffd60e95b02a0" ] [inputs.previous_rollups.vk_data.vk] key = [ - "0x0000000000000000000000000000000000000000000000000000000000000015", - "0x00000000000000000000000000000000000000000000000000000000000000a3", + "0x0000000000000000000000000000000000000000000000000000000000000017", + "0x00000000000000000000000000000000000000000000000000000000000000a5", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x000000000000000000000000000000f3dd0027a9bf9c90623274e2cc4875fbfd", - "0x00000000000000000000000000000000002a19be4ee556f81b7cbc51e13981b9", - "0x0000000000000000000000000000006d291b56c49351fc5a528fd75fbbf1c83b", - "0x00000000000000000000000000000000001ed738716857bcff1d30c099caddf0", - "0x000000000000000000000000000000e70468dab546f5284ddfc417d7478d50a7", - "0x00000000000000000000000000000000002634edf447b025ff7b0f031c1d6898", - "0x000000000000000000000000000000cb51451d962a6b1373a5566882e3bd7612", - "0x000000000000000000000000000000000022d2ad6385d6c74a2288c40f27ebba", - "0x000000000000000000000000000000259e820c9844f19c90497d75ccce660ac6", - "0x000000000000000000000000000000000016eef7f67298ae6159c36a0fa3b2fe", - "0x00000000000000000000000000000061222490df831b2aa7b8aa9af315e096da", - "0x00000000000000000000000000000000002bb5ae61acd094f19640ebfbff6ef5", - "0x00000000000000000000000000000067fcdc39c34668b73db34138fa2a13d42b", - "0x000000000000000000000000000000000005edc94bba74d353b164ad0f90b1a5", - "0x000000000000000000000000000000743f06c041c3427babcaca40dd044d4600", - "0x00000000000000000000000000000000002caddbb3ed06bc9a68b956e71b7b8c", - "0x000000000000000000000000000000298d5ff6c30fa2c6aaa462da0b8026dcf6", - "0x00000000000000000000000000000000000dbf750297b0120823ac105092b636", - "0x000000000000000000000000000000eefbda437339cd7ccd82615d7fc3055b8a", - "0x0000000000000000000000000000000000095a30873abbdcab60be8cb914002b", - "0x0000000000000000000000000000005fca3b5450b4a333f804ed504abb5f222a", - "0x000000000000000000000000000000000014c5cbb7c9e0298a8e3bf402349a7c", - "0x0000000000000000000000000000005f47381b518fe4c3b7a18b19e681bbbfc9", - "0x000000000000000000000000000000000003d309068671af359529cf66887086", - "0x000000000000000000000000000000b394609589f105b795e4766958d7e47627", - "0x00000000000000000000000000000000002701a644dee43ce6f48a05ca60148d", - "0x000000000000000000000000000000f9c3f63945c15da781a5d4f67a4e13e279", - "0x00000000000000000000000000000000001b1b6eda68dcd4d392f18b3239267e", - "0x0000000000000000000000000000004020a1c978fdc4b03b701c5ae4342661e2", - "0x00000000000000000000000000000000000fa4d30bed48c7aef7caeb872e6b46", - "0x0000000000000000000000000000006bc830878b123b5a8039753f5fc28f9f56", - "0x00000000000000000000000000000000000686c78e1454d26d0298ab5a461bef", + "0x0000000000000000000000000000003288730860744d90f8dcdc13940fc8d87e", + "0x00000000000000000000000000000000001a6480ae73e5d86fc292b430b8a751", + "0x0000000000000000000000000000006917a325f36c3d0079ea3a8a3f1163f738", + "0x0000000000000000000000000000000000040b3b47fc35b7e61722173a8585ca", + "0x000000000000000000000000000000bd731678729bd1076face8dda8d5fdd33e", + "0x000000000000000000000000000000000010d5115052c7b5d12f7f7fd39c73b1", + "0x000000000000000000000000000000143cbf9cb288d55c919de0d3c6b5f418d8", + "0x000000000000000000000000000000000017dbc3182e0956e2ed401eabcc8f94", + "0x00000000000000000000000000000079c549a08f8e493ac82a3298d5020166a1", + "0x00000000000000000000000000000000000f15af4534a6f141858cc1ea55d87c", + "0x0000000000000000000000000000000d5ecf557d36b122ff3d2384ed60de9d98", + "0x000000000000000000000000000000000008816a47846bc89240d2e13c362be1", + "0x000000000000000000000000000000e315f3df73d78bae1d02fa60b3a7a3ec68", + "0x0000000000000000000000000000000000093e3211a055f01f562492428baea9", + "0x00000000000000000000000000000027ebb9883a8e78bd492c14bd0cb85a6e19", + "0x00000000000000000000000000000000001b7795648f8c1f9c520a9f842dc5be", + "0x00000000000000000000000000000035a06493c8f34e1fae3efa0c4c3d529858", + "0x00000000000000000000000000000000002456fd877795105f730069fc1fb9ef", + "0x000000000000000000000000000000c30ebb23e62d30c6a395834e91224c7111", + "0x000000000000000000000000000000000028e695b7da8c77dc517e5e3cc3c28d", + "0x0000000000000000000000000000006720355f00860876fb20c803fcddcf9b4e", + "0x00000000000000000000000000000000000ab7e9481137a97e36d8ced967c1ed", + "0x000000000000000000000000000000fcc8b48bedce5374db954ff6d9d4e5d59a", + "0x00000000000000000000000000000000001134dbc1b6735b7ebc219367c7cbbc", + "0x000000000000000000000000000000dd98d271d4d16e66d61039d006fdb08dd2", + "0x00000000000000000000000000000000002646eb78d367e3ddae2ee29657e78f", + "0x0000000000000000000000000000006e859a711aa7352e651b1b48330125a03a", + "0x000000000000000000000000000000000021784c3d16da5e715233b84c49fe1b", + "0x000000000000000000000000000000d4eed6e91e831b6232254e64a82fa8d212", + "0x00000000000000000000000000000000000b106a845234acad6cfaffc55cf2ff", + "0x0000000000000000000000000000005194ac5554bc31446a2822c2a90ee5d536", + "0x00000000000000000000000000000000001a0209e186160b00c1d9f45845ad40", + "0x000000000000000000000000000000513eaa372ee3ab77c56296538ca4437f01", + "0x000000000000000000000000000000000017aa55310d97d1bef2ce1f2a2e58f5", + "0x000000000000000000000000000000547582ffb04f9f2dc83dc8dd4ac9353afa", + "0x000000000000000000000000000000000009f0c660d3c44b7d47f82eae5c6e37", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000006691d9edd4281b4d8c7bfe7cf2114dbed0", + "0x00000000000000000000000000000000002f785826e92b236b3f40d64938a8af", + "0x0000000000000000000000000000001f2e233e205ebb1de17e51bd42bd2a6709", + "0x0000000000000000000000000000000000244972df89429a8780722959797160", + "0x000000000000000000000000000000a08687feb5bb3bbe8fa68abee82250cf45", + "0x00000000000000000000000000000000002b5b8e1d2121016a592d83cddf49fa", + "0x000000000000000000000000000000bc66f21b8eed9da44989f70a272822b6f7", + "0x000000000000000000000000000000000023bccb8cecf793ebbb1bda19fd1490", + "0x00000000000000000000000000000062017a22ba729a464723c1312a7b69c9bc", + "0x00000000000000000000000000000000001dac218f0b46fda3d521146527e842", + "0x000000000000000000000000000000ca406376e1831ce97513fe24aeed962561", + "0x0000000000000000000000000000000000294fc4df9082aa7fd5b670738928ec", + "0x0000000000000000000000000000008b9b647e54171de19e0b6f93ef5e48ac1b", + "0x00000000000000000000000000000000000f9038e596e4bc37a8636a2d461327", + "0x0000000000000000000000000000009f1ce1c28c8577cfc8339465e9d8f5b742", + "0x00000000000000000000000000000000001309f9dda0064b07081016e15d07ad", + "0x00000000000000000000000000000024222df0aa0ffa760557d17021c98eece7", + "0x00000000000000000000000000000000001d15b2767580e54d9ea596a65c9523", + "0x000000000000000000000000000000df15a11026f7fac6f9d648764a34019e0f", + "0x00000000000000000000000000000000002ce785169d9a643bb94c4af25cd196", + "0x000000000000000000000000000000308adcca358d6672a7b1866c24db257984", + "0x0000000000000000000000000000000000125b3d6f343c08e90f7a5c5e9d1711", + "0x000000000000000000000000000000e5dfaa669b75a8b832f3ae92f41a676f75", + "0x0000000000000000000000000000000000130e53472be61d363fe04154c25ad8", + "0x000000000000000000000000000000b77240211fc58c69db333948fec925ae5b", + "0x00000000000000000000000000000000000885c9c1fa31d3e07be8a05b37c862", + "0x0000000000000000000000000000003e1988529ef3e8c0f71d3bb9c5eabb0c93", + "0x00000000000000000000000000000000002f259eb9cf86aa730d5fd3307582c7", + "0x000000000000000000000000000000ff9c398f86a183fcbc41c36d7ea5486f44", + "0x00000000000000000000000000000000001d741554ae0921d8439277b831b59f", + "0x00000000000000000000000000000072f4ba06e6c859cafd74b8be78f4e6c290", + "0x000000000000000000000000000000000013c4ca91ce5c6256578e79b70a67f0", + "0x0000000000000000000000000000000dd655425a18bf1b28d418c22e417aed28", + "0x0000000000000000000000000000000000020fc7fbb26d277c22bd7780447291", + "0x000000000000000000000000000000ffb9ad1af1a082c77b4e0810594467c569", + "0x000000000000000000000000000000000020aa42c226d5a0970630ddbb783f38", + "0x000000000000000000000000000000bf3e76d8f3f21653422411fcd9a2bd5ae0", + "0x0000000000000000000000000000000000187d106d31fd0f38d51f99eab75ce7", + "0x000000000000000000000000000000cbf23559d5b4a16dc60742408bc4d980c8", + "0x00000000000000000000000000000000001fd1cc7837e440e779a50f76b58a2e", + "0x000000000000000000000000000000eb62206940246d32198b3141bc6a50abac", + "0x0000000000000000000000000000000000037f231e8cd28f0f8ad3cb5f466032", + "0x000000000000000000000000000000efc0ca88f857d42b88ac1ac92d9374b62d", + "0x00000000000000000000000000000000001fd02630798bd4633975daf091b593", + "0x000000000000000000000000000000da2f92a05047e7e8b1a822549759808b83", + "0x000000000000000000000000000000000001084dd81798c00eeb2887f2df9620", + "0x00000000000000000000000000000011fc26a27e002528f461224894ccd240ee", + "0x00000000000000000000000000000000001534fa0d9bbd25eba2f122eaad06bc", + "0x0000000000000000000000000000009f3672e356e98b3a7a3deae61a9b87dd29", + "0x0000000000000000000000000000000000301cc7d23879687ec5cbdc195436f9", + "0x00000000000000000000000000000023885c7bce9e0d10196c6f831bf4b229de", + "0x00000000000000000000000000000000001602ff1fe4f4cb70c26ad5bc16858a", + "0x000000000000000000000000000000fcf2a0c1eceb385200a0ee09c40c758fbf", + "0x0000000000000000000000000000000000253b9dd23a0982e9db87324acd9aba", + "0x00000000000000000000000000000097a1599a0f5c04ef46d89bc4be8629ed3f", + "0x00000000000000000000000000000000002ef5dbc090a304ab4d948f1e08a8de", + "0x000000000000000000000000000000691acea534b501c5d7a5984cbb56e2f677", + "0x0000000000000000000000000000000000256377fe9f1696e2316a0ede70e194", + "0x000000000000000000000000000000b1d93380e5a238c52f4d9327b8ff615f45", + "0x0000000000000000000000000000000000029f05bf11aee014fc3ca870e42dc7", + "0x00000000000000000000000000000083f400e03505d6e2e6a8d315ec5b24f54c", + "0x00000000000000000000000000000000000c031249619645a60ab26bf3069331", + "0x0000000000000000000000000000006e7016f5ace833e2821d171ef0fe2b9f8d", + "0x00000000000000000000000000000000000f8b062a1227fc7a323aed56615912", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x00000000000000000000000000000004c85ca29bf8c683168a980c9a3397e522", - "0x00000000000000000000000000000000001e30d912e04a18b2014b734fb6c293", - "0x00000000000000000000000000000068c88aa053154f24a7cd3a9e5062ce9533", - "0x00000000000000000000000000000000000f1013091f36c091808d58cf427546", - "0x000000000000000000000000000000f09823147b5a2f1315af76f84626faacc5", - "0x00000000000000000000000000000000002cfa957d32526624e97ec08d0763b4", - "0x00000000000000000000000000000095f75874399828c93364b7d272bdd91ad8", - "0x0000000000000000000000000000000000169d8b404b534c0a246767dc1b6cc2", - "0x000000000000000000000000000000c5cafa7e75b7c69af15b1a1e1bc905d603", - "0x00000000000000000000000000000000000056634d879eaebb861aab7f6f754f", - "0x00000000000000000000000000000075b6c4cb8ee2d596e52fe1b3d9405cb208", - "0x00000000000000000000000000000000002bf855c3a58ee0e60041a921be728b", - "0x000000000000000000000000000000a4e608225e21e96a15388fd855afcb8bd9", - "0x000000000000000000000000000000000001eb45674390c99d0df7b66959f3a6", - "0x000000000000000000000000000000da7a7c3519858b8c78980a95a3c0ace91c", - "0x000000000000000000000000000000000004b30cecdd534cbfb3c9ffdf2ef2c3", - "0x0000000000000000000000000000003a35ed1dc0d1ff7aae4209529a34930921", - "0x0000000000000000000000000000000000210c99ed727129a1d40e9f9a7adcaf", - "0x000000000000000000000000000000fd35d6cbde8ca6b8e64652a47a495d4eac", - "0x000000000000000000000000000000000019c18ce002d04e602c1607ffe9a256", - "0x0000000000000000000000000000005e643893fe0397c603829ee5eec8cd1b57", - "0x00000000000000000000000000000000000e58f7d675efa17dc8fb8784a3d3ec", - "0x00000000000000000000000000000001a62a5467501b9ba3f907057f217c5842", - "0x0000000000000000000000000000000000085ee99d6a97c76d6b87ed12e998dd", - "0x00000000000000000000000000000019fa1cc7006ec07a362874e5899347d3b5", - "0x00000000000000000000000000000000002dd21ac74693f12eae15e19ac3f4e9", - "0x0000000000000000000000000000005a1ea35dfbcf743b3ce11ce2e8629f19e6", - "0x00000000000000000000000000000000002fa64b3bd8b9921723317b2b3bc016", - "0x00000000000000000000000000000000c8749e8b44fbafa0cb783908f71ca43c", - "0x00000000000000000000000000000000000452edc05eda610ee588e3bf496292", - "0x000000000000000000000000000000d9780c71504a1870651ec671b124a36f6f", - "0x00000000000000000000000000000000002e594354b67060c97f311225fa34ae", - "0x000000000000000000000000000000170753b4fb55d2a839346eaa20855c2ce7", - "0x000000000000000000000000000000000006c3bdda1a4d3ece70c8a57f1f0263", - "0x0000000000000000000000000000003dd4b48e3e37919c109c3b18cc3b2265a7", - "0x0000000000000000000000000000000000152eca2c022ee0e6340d62891c5228", - "0x00000000000000000000000000000027857e742687fcbb8a1776c44fc89bd992", - "0x00000000000000000000000000000000000d43515b1f31d2c281a679e9a60597", - "0x00000000000000000000000000000021a6c141043aba99a2455fe9d3162aea31", - "0x0000000000000000000000000000000000116eca793064aa52816099d7b1b856", - "0x00000000000000000000000000000080d8af2c3a7eb09247b224d69feb59db7f", - "0x00000000000000000000000000000000000cdc3dc774bc9cf885f22340c55e34", - "0x0000000000000000000000000000009b3dce5761fcef7f34b7daefcac691acfc", - "0x0000000000000000000000000000000000175cc08fc63b1b7e3d01ac07be17ba", - "0x0000000000000000000000000000000fdb0290862616c081ab8bcf9871c309c2", - "0x00000000000000000000000000000000002bff3e69b075b3aa3104ab8b4b0c55", - "0x0000000000000000000000000000003b79cb77993965a3aadd9ca90e23180bdf", - "0x00000000000000000000000000000000002b82418b647333b049ddb4a0f00036", - "0x0000000000000000000000000000003ee1123375c63e3aa50d9b10730a110f2b", - "0x000000000000000000000000000000000029a5aef768ee4d574df39792435c39", - "0x000000000000000000000000000000b04cfb4ff8a6a6f75c3c12e7c3907fe47c", - "0x000000000000000000000000000000000007e07a88f0efa047b6d1159e5433c6", - "0x0000000000000000000000000000000380f8a411e8cd6729fc91b78f0a7e30e4", - "0x00000000000000000000000000000000002c12b6bf8709a904fa3125c44e700f", - "0x000000000000000000000000000000cd7ca3e9ed8bb9a6121f522023dfa8b26e", - "0x0000000000000000000000000000000000283538b42da44b4bec7290be552dfd", - "0x000000000000000000000000000000662f3ca47840d128223a7eccf2f8bfdc96", - "0x000000000000000000000000000000000024d658e9e6acb83221331c656807d3", - "0x000000000000000000000000000000f85d8aab4282d54e5f0eeb7c2135fd427a", - "0x00000000000000000000000000000000002599d73eb9093c7a13848d307874a0", - "0x000000000000000000000000000000ff7ddb01808894d4e1f81d238eb5869363", - "0x00000000000000000000000000000000000ae65f87c37152d4c5e012874d5bf0", - "0x0000000000000000000000000000006793e0f1bf87ca4917287881df03901ad7", - "0x000000000000000000000000000000000005e93e00058f2566596a419f9dc5ce", - "0x000000000000000000000000000000767da639e35d5d1ef71478a950cf288513", - "0x00000000000000000000000000000000002afd252e8615e7eeda46b48225961d", - "0x0000000000000000000000000000007def46ee76f6ea569e02646c04537d31e0", - "0x00000000000000000000000000000000001fe6504150f81283f95b42498506a4", - "0x000000000000000000000000000000a4c1f600b7652e539371dc66a0e235337d", - "0x00000000000000000000000000000000000b101b006770c17530fa8330b6dc04", - "0x00000000000000000000000000000074377052aa69f94a755cde3f9ce8138ce2", - "0x0000000000000000000000000000000000165266c7414a3b474914dba91316bd", - "0x000000000000000000000000000000a8ed603c54c796e5ec3c7cc3caa2d33449", - "0x0000000000000000000000000000000000043a3877cf735247a6a67190477bea", - "0x000000000000000000000000000000d63cbc50845d49f0709bb8eff860f4a382", - "0x0000000000000000000000000000000000270e1c50ec474ac2fd022ba73c40f2" + "0x000000000000000000000000000000328fa44eadf895a91d60516902155f8f81", + "0x0000000000000000000000000000000000071b9cc79e0dca76ef8aa121fecb42", + "0x000000000000000000000000000000f643b83d95fb7587ac2fc95b9f12d855a2", + "0x00000000000000000000000000000000002b1fcc8551667432c54702bead052b" ] - hash = "0x1f58925ff616b4fd1e9957536f379ea1a3a79bad46033bd094797cf1000f5fa4" + hash = "0x0fc08e493f377c56c666df99d9f3a5dbae52b12f02c75885ea759a74406efa80" [[inputs.previous_rollups]] proof = [ @@ -1436,9 +1438,11 @@ proof = [ ] [inputs.previous_rollups.public_inputs] + start_inbox_rolling_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" + end_inbox_rolling_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" checkpoint_header_hashes = [ - "0x0004d83706262d94ec97b0559d4e179a4f09a706bb9eb8b2058a66c51326acf6", - "0x002aac8a431c2893be6234fa1bad8e46feaa3f51f373e8257ae75b10d086b9eb", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000000000000000000000000000", @@ -1472,39 +1476,39 @@ proof = [ ] [inputs.previous_rollups.public_inputs.constants] - chain_id = "0x0000000000000000000000000000000000000000000000000000000000007a69" - version = "0x000000000000000000000000000000000000000000000000000000005fe47cc3" - vk_tree_root = "0x1cd59fb7641f17e0fe2998b3ebc3c3d71e3f4ad4eeb883be55e3bf04749fe247" - protocol_contracts_hash = "0x080e3881bdd4a4e78d52691e5543b50cf820f51baf52af42d7b58c9e15f96ec7" - prover_id = "0x0000000000000000000000003c44cdddb6a900fa2b585dd299e03d12fa4293bc" + chain_id = "0x0000000000000000000000000000000000000000000000000000000000000000" + version = "0x0000000000000000000000000000000000000000000000000000000000000000" + vk_tree_root = "0x0000000000000000000000000000000000000000000000000000000000000000" + protocol_contracts_hash = "0x0000000000000000000000000000000000000000000000000000000000000000" + prover_id = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.previous_archive] - root = "0x02b768bc715afcefe7acc2a4394dc1ec3d36e9051f52662c42c795597ad03956" - next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000d" + root = "0x0000000000000000000000000000000000000000000000000000000000000000" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.new_archive] - root = "0x253b8ea9561900b964ddb9bbc5e4545faa4fb79db30b2da3643242530c2ab4f7" - next_available_leaf_index = "0x000000000000000000000000000000000000000000000000000000000000000f" + root = "0x0000000000000000000000000000000000000000000000000000000000000000" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.previous_out_hash] - root = "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000004" + root = "0x0000000000000000000000000000000000000000000000000000000000000000" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.new_out_hash] - root = "0x00c95e0ceb41951039e1592745ec2faea9866f6eaf01bf189a4463b4143af093" - next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000006" + root = "0x0000000000000000000000000000000000000000000000000000000000000000" + next_available_leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000000" [[inputs.previous_rollups.public_inputs.fees]] - value = "0x0000000000000000000000000000000000000000000000000001646623a26e00" + value = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.fees.recipient] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [[inputs.previous_rollups.public_inputs.fees]] - value = "0x000000000000000000000000000000000000000000000000000083a35fe8cc00" + value = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.fees.recipient] - inner = "0x00000000000000000000000096a3970e323d4410d1f969fdea80c679edfca17f" + inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [[inputs.previous_rollups.public_inputs.fees]] value = "0x0000000000000000000000000000000000000000000000000000000000000000" @@ -1687,219 +1691,219 @@ proof = [ inner = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.start_blob_accumulator] - blob_commitments_hash_acc = "0x003c3d7634e4804fa2d1579984557d5e0f193db092992632750e0f02435c536e" - z_acc = "0x2e5590725ce897557051bcd8e235179ca85612f775e25899d41e2e6d429bab8f" - gamma_acc = "0x1a92da981183c7c99558cbbf36266f907c24981e57e22325cd913d6c0b511f0c" + blob_commitments_hash_acc = "0x0000000000000000000000000000000000000000000000000000000000000000" + z_acc = "0x0000000000000000000000000000000000000000000000000000000000000000" + gamma_acc = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.start_blob_accumulator.y_acc] limbs = [ - "0x51460e3323b2335762b279af363d8f", - "0xfb02d1de4f7cbf4de93446d5162177", - "0x64ca" + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x0000" ] [inputs.previous_rollups.public_inputs.start_blob_accumulator.c_acc] - is_infinity = false + is_infinity = true [inputs.previous_rollups.public_inputs.start_blob_accumulator.c_acc.x] limbs = [ - "0xe30b704d93a13e80d6b61851ffbb42", - "0xa6582dfbfe7c7fb2e4cb46ca26a4a9", - "0x58d8f47578a73f78ec55404027113b", - "0x088313" + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x000000" ] [inputs.previous_rollups.public_inputs.start_blob_accumulator.c_acc.y] limbs = [ - "0xac35297801db6e89bc7c01cccf1c2c", - "0x5a8cdb9c6da878c061855cde01bada", - "0xf8ade47e6b400bf343963bce4206ac", - "0x02c72c" + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x000000" ] [inputs.previous_rollups.public_inputs.start_blob_accumulator.gamma_pow_acc] limbs = [ - "0xf3d1444be1d67a5ae57a7a5347f063", - "0xd40b5f08dc03ca05b5c582e87600d8", - "0x11f8" + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x0000" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator] - blob_commitments_hash_acc = "0x002ef8497a6a3685caf08c21021103b7296ab9f749a488e56b8db55182d8d4ae" - z_acc = "0x1fdc12adc29013642cd3e65ed4fe6257a51f0de3dbf9aab308d2eb764d2e2a6c" - gamma_acc = "0x1071981792a53848b917053086bc7150d9d1cf18ffa05498555c36810bcecafd" + blob_commitments_hash_acc = "0x0000000000000000000000000000000000000000000000000000000000000000" + z_acc = "0x0000000000000000000000000000000000000000000000000000000000000000" + gamma_acc = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.end_blob_accumulator.y_acc] limbs = [ - "0xb60ca1feed35bf28340ef17cd871b9", - "0x698569825a1ff49eccccd108c34514", - "0x5410" + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x0000" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc] - is_infinity = false + is_infinity = true [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc.x] limbs = [ - "0x43aaf3d0c121b4d96780dd687e365d", - "0xededee37534fd55f1e3decf2d6631a", - "0x788976bdd69c9611dc7639f3de0668", - "0x165528" + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x000000" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.c_acc.y] limbs = [ - "0x7132fd22120449831964d6a5a42921", - "0xf87224d4a7813465361b659fbc6c27", - "0x7fc9439e7e2242a18bdfd802227a55", - "0x133ea3" + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x000000" ] [inputs.previous_rollups.public_inputs.end_blob_accumulator.gamma_pow_acc] limbs = [ - "0xdc7bf8e5c80213b175acab6de8764d", - "0x2602f93c359de53d2a3f3a57561292", - "0x4978" + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x0000" ] [inputs.previous_rollups.public_inputs.final_blob_challenges] - z = "0x1fdc12adc29013642cd3e65ed4fe6257a51f0de3dbf9aab308d2eb764d2e2a6c" + z = "0x0000000000000000000000000000000000000000000000000000000000000000" [inputs.previous_rollups.public_inputs.final_blob_challenges.gamma] limbs = [ - "0x3091f45075ebc6c0e8bd0d0b55148a", - "0xba36f4511ca8e170b8a14a64a7418f", - "0x070d" + "0x000000000000000000000000000000", + "0x000000000000000000000000000000", + "0x0000" ] [inputs.previous_rollups.vk_data] - leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000013" + leaf_index = "0x0000000000000000000000000000000000000000000000000000000000000012" sibling_path = [ - "0x1e7976567fc760772e92450d8ac6f02ef47edb23baa7459dc33c0ceb6c88497d", - "0x23545acba1dbc9308d912f371ee6d2f31ab1da4eccf3d019473d8ab7205adf27", - "0x035c573a1f2634405482213a2b805e186d6b81073e2b7a5bd3f64c2e4e8bc21e", - "0x033c4d295fe10d44c10ab7dd6b98731454b30ab8a3b175477338750c07bc4023", - "0x234c347546637311dad66534e5274a6a5db5da51b51baab040dac88807024ce5", - "0x118d25fdd2c4cc96d5af69bd85930dd49d101d463e3f5ee9f2cc9236384b5d41", - "0x19dd00df005acafea7173682679ac59d437120260bc4c6179b6dc40d3154cfed" + "0x1f6cca1ce2f0e042c42aa30b4434d9939338bb7754e104720e0f02aaf090ded0", + "0x2395a9dc1e026aa5e011d76b53d5c67302fcf805faae9f3ad9601b485b586e43", + "0x2e786d2377d9994a6dab998e113d87924b5b55a476ff385d0c66bcbb91158c60", + "0x20738d93e695096c6290e7c275252b87c3fc8a419bd4d9991368484bcbd446a7", + "0x2ea23c9cbeafe466f3725ea750741efad48745849cf61628cb3cd0e6156c6246", + "0x187a7b8872d1297bc15f7171f32c36e5e60b53c4145ef62b1899c04fd7220fdf", + "0x2ccaede67145021b6b586f45936dfbdacb151c3e362621c3598ffd60e95b02a0" ] [inputs.previous_rollups.vk_data.vk] key = [ - "0x0000000000000000000000000000000000000000000000000000000000000015", - "0x00000000000000000000000000000000000000000000000000000000000000a3", + "0x000000000000000000000000000000000000000000000000000000000000000c", + "0x00000000000000000000000000000000000000000000000000000000000000a5", "0x0000000000000000000000000000000000000000000000000000000000000005", - "0x000000000000000000000000000000f3dd0027a9bf9c90623274e2cc4875fbfd", - "0x00000000000000000000000000000000002a19be4ee556f81b7cbc51e13981b9", - "0x0000000000000000000000000000006d291b56c49351fc5a528fd75fbbf1c83b", - "0x00000000000000000000000000000000001ed738716857bcff1d30c099caddf0", - "0x000000000000000000000000000000e70468dab546f5284ddfc417d7478d50a7", - "0x00000000000000000000000000000000002634edf447b025ff7b0f031c1d6898", - "0x000000000000000000000000000000cb51451d962a6b1373a5566882e3bd7612", - "0x000000000000000000000000000000000022d2ad6385d6c74a2288c40f27ebba", - "0x000000000000000000000000000000259e820c9844f19c90497d75ccce660ac6", - "0x000000000000000000000000000000000016eef7f67298ae6159c36a0fa3b2fe", - "0x00000000000000000000000000000061222490df831b2aa7b8aa9af315e096da", - "0x00000000000000000000000000000000002bb5ae61acd094f19640ebfbff6ef5", - "0x00000000000000000000000000000067fcdc39c34668b73db34138fa2a13d42b", - "0x000000000000000000000000000000000005edc94bba74d353b164ad0f90b1a5", - "0x000000000000000000000000000000743f06c041c3427babcaca40dd044d4600", - "0x00000000000000000000000000000000002caddbb3ed06bc9a68b956e71b7b8c", - "0x000000000000000000000000000000298d5ff6c30fa2c6aaa462da0b8026dcf6", - "0x00000000000000000000000000000000000dbf750297b0120823ac105092b636", - "0x000000000000000000000000000000eefbda437339cd7ccd82615d7fc3055b8a", - "0x0000000000000000000000000000000000095a30873abbdcab60be8cb914002b", - "0x0000000000000000000000000000005fca3b5450b4a333f804ed504abb5f222a", - "0x000000000000000000000000000000000014c5cbb7c9e0298a8e3bf402349a7c", - "0x0000000000000000000000000000005f47381b518fe4c3b7a18b19e681bbbfc9", - "0x000000000000000000000000000000000003d309068671af359529cf66887086", - "0x000000000000000000000000000000b394609589f105b795e4766958d7e47627", - "0x00000000000000000000000000000000002701a644dee43ce6f48a05ca60148d", - "0x000000000000000000000000000000f9c3f63945c15da781a5d4f67a4e13e279", - "0x00000000000000000000000000000000001b1b6eda68dcd4d392f18b3239267e", - "0x0000000000000000000000000000004020a1c978fdc4b03b701c5ae4342661e2", - "0x00000000000000000000000000000000000fa4d30bed48c7aef7caeb872e6b46", - "0x0000000000000000000000000000006bc830878b123b5a8039753f5fc28f9f56", - "0x00000000000000000000000000000000000686c78e1454d26d0298ab5a461bef", + "0x000000000000000000000000000000b00d67fbc2caa70fdd0bd3b337dd11b8ed", + "0x000000000000000000000000000000000016245a29ff339811781222b2740a74", + "0x000000000000000000000000000000abbfe0482d5c93d6349a709c58337fcb8d", + "0x000000000000000000000000000000000024c2a5fcb33c386f63fadf7a3ffb00", + "0x0000000000000000000000000000007248127e960f07383be9cb74ef2470cc0b", + "0x00000000000000000000000000000000002b96a06fab78b22fcace8b4070a989", + "0x000000000000000000000000000000324757a9f9265992aa248e34ed25e8133b", + "0x000000000000000000000000000000000003fa305e0b0804b2ee3c0f7603c5d7", + "0x000000000000000000000000000000eba8c64f7f53f2da452a3ec99147d827b6", + "0x00000000000000000000000000000000002a0b6329fd782bdb2e86c36a3c6582", + "0x000000000000000000000000000000fd97d949b09a00fd0d8db5d3b8bfa0b82d", + "0x00000000000000000000000000000000002b2881621ff875a9c4f802a0ad3efd", + "0x000000000000000000000000000000444001256044e0bf83954108525c07f8d0", + "0x00000000000000000000000000000000000a1fc8db190ab9d20829e6413925ed", + "0x000000000000000000000000000000431cc0a1600d5355297cc712bb4c2a422e", + "0x00000000000000000000000000000000002240c414b644cb8adfe16555116f5a", + "0x000000000000000000000000000000f09b1d8d8f55f61c67f867d9f334de9ab0", + "0x00000000000000000000000000000000001ffd5ee5f381d3e582b95979ce6338", + "0x000000000000000000000000000000f6a11e6609de1a389609bb85f1a84626f3", + "0x000000000000000000000000000000000017a6f1561d9b913c9989d7ca07f413", + "0x00000000000000000000000000000091002843edeae9e3cf15528a5999bbd350", + "0x0000000000000000000000000000000000289afffdcd7b17f51b6b6f7310414e", + "0x000000000000000000000000000000e6c14854c824b5342f1a57671dc954322a", + "0x00000000000000000000000000000000002b1188993dba8da6145250d8c18a6d", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000006fa41747fdec8819b6e899563259e5f3c6", + "0x000000000000000000000000000000000020f78d6cb618375a58d8039cbbe95a", + "0x000000000000000000000000000000bd81bfa81ae056999ab4f6de054e3067d4", + "0x000000000000000000000000000000000006c3ee65fcd76a731d9db949113260", + "0x000000000000000000000000000000c6b8f74f0c78b6e2a31d6950c7bdccf8f6", + "0x00000000000000000000000000000000000bbef400fb7ca9778f1d874ca581d6", + "0x000000000000000000000000000000366187bf840bb19f3b3f3a9cb668837016", + "0x000000000000000000000000000000000009c808ffdcd7ebd05c9c8a6c0b5fe2", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000008c2de12a23e5bc60f4fa838a0dadde0a89", + "0x0000000000000000000000000000000000232a4873260f5774bfa580e0ed8741", + "0x0000000000000000000000000000007af9d52d5c49322de98cd9f5bb718d6bfa", + "0x0000000000000000000000000000000000181e32ab40464653b89481cd801494", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000001aa2e6a7eefcf67a1c54a49ff0a81aa790", + "0x000000000000000000000000000000000017203bebc1aa1938ef9268ea3ca89c", + "0x000000000000000000000000000000a61e1b17525b908a9f4b6a8376cf5fca7e", + "0x000000000000000000000000000000000012466ca65d98b691bbf931acfe1b7a", + "0x0000000000000000000000000000008b31bffcdde7c529f04c24902a1c2f0e78", + "0x0000000000000000000000000000000000242178a54cf9609bcb9195fd002ffe", + "0x000000000000000000000000000000d6512c0b39c067dd15e0580e5e4b2a567e", + "0x0000000000000000000000000000000000067c4c8b4b3f12889b70b91e76c429", + "0x00000000000000000000000000000097dd9450d1b681c88735875fcc6d0b4f61", + "0x000000000000000000000000000000000005c0627478cb8eac9ae816df6fbcda", + "0x000000000000000000000000000000c2a8966d4023907b10a1e714e9e8892b1b", + "0x00000000000000000000000000000000001ce75e6d831343969da02c1d02c600", + "0x000000000000000000000000000000ccccd71b8f35ae5cf291771d950f68f3da", + "0x000000000000000000000000000000000003c4d39cdc62445481623e62aee2eb", + "0x0000000000000000000000000000007866c0021c809de9466d440ed11ad06e2d", + "0x00000000000000000000000000000000001be4807329f829d87fe72bc72ea425", + "0x00000000000000000000000000000034db09f2a0954e121607b022f655bea165", + "0x00000000000000000000000000000000002fd4277bc2dc6982e34890d4b49682", + "0x000000000000000000000000000000f8cb23cce947a97193ae91204b3689fba9", + "0x000000000000000000000000000000000013cafea361342986c4d452947efe2b", + "0x000000000000000000000000000000cc44ebd033adff111038b46546004dcb75", + "0x00000000000000000000000000000000000d96f091add60f8747307f2d6f72f0", + "0x000000000000000000000000000000b3c22cb3f7c6722416b4b660c29fd79b94", + "0x00000000000000000000000000000000000b9289b001e07a165bf4d98cf60b31", + "0x0000000000000000000000000000005cc837a8b9babe98e7889b46f76641226b", + "0x0000000000000000000000000000000000290d6792db836056ee48c04d257023", + "0x0000000000000000000000000000007c315ccad12ec8ed76fdebae4a372267a3", + "0x000000000000000000000000000000000025ea4c55c9f64a9d9a29509137aea8", + "0x00000000000000000000000000000078ee5f9a2c619405dd3c7bdb0e09350100", + "0x00000000000000000000000000000000000b10e34e2703d335ff9a3a855df9a4", + "0x000000000000000000000000000000c834ba6990f3ecb2dbe630e41b9cadc7de", + "0x00000000000000000000000000000000001e589991bea6d97a496fcc27aa76a7", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x0000000000000000000000000000000000000000000000000000000000000000", "0x0000000000000000000000000000001eee81b23a887f299049b14c11e98460d6", "0x00000000000000000000000000000000002a56ce41f6b0be13b9c26747621b82", "0x000000000000000000000000000000d5827d6338c78656c0d12ca1aea6ef2c7c", "0x00000000000000000000000000000000001aa98f2de3ddda547d8f6de4e725de", - "0x00000000000000000000000000000004c85ca29bf8c683168a980c9a3397e522", - "0x00000000000000000000000000000000001e30d912e04a18b2014b734fb6c293", - "0x00000000000000000000000000000068c88aa053154f24a7cd3a9e5062ce9533", - "0x00000000000000000000000000000000000f1013091f36c091808d58cf427546", - "0x000000000000000000000000000000f09823147b5a2f1315af76f84626faacc5", - "0x00000000000000000000000000000000002cfa957d32526624e97ec08d0763b4", - "0x00000000000000000000000000000095f75874399828c93364b7d272bdd91ad8", - "0x0000000000000000000000000000000000169d8b404b534c0a246767dc1b6cc2", - "0x000000000000000000000000000000c5cafa7e75b7c69af15b1a1e1bc905d603", - "0x00000000000000000000000000000000000056634d879eaebb861aab7f6f754f", - "0x00000000000000000000000000000075b6c4cb8ee2d596e52fe1b3d9405cb208", - "0x00000000000000000000000000000000002bf855c3a58ee0e60041a921be728b", - "0x000000000000000000000000000000a4e608225e21e96a15388fd855afcb8bd9", - "0x000000000000000000000000000000000001eb45674390c99d0df7b66959f3a6", - "0x000000000000000000000000000000da7a7c3519858b8c78980a95a3c0ace91c", - "0x000000000000000000000000000000000004b30cecdd534cbfb3c9ffdf2ef2c3", - "0x0000000000000000000000000000003a35ed1dc0d1ff7aae4209529a34930921", - "0x0000000000000000000000000000000000210c99ed727129a1d40e9f9a7adcaf", - "0x000000000000000000000000000000fd35d6cbde8ca6b8e64652a47a495d4eac", - "0x000000000000000000000000000000000019c18ce002d04e602c1607ffe9a256", - "0x0000000000000000000000000000005e643893fe0397c603829ee5eec8cd1b57", - "0x00000000000000000000000000000000000e58f7d675efa17dc8fb8784a3d3ec", - "0x00000000000000000000000000000001a62a5467501b9ba3f907057f217c5842", - "0x0000000000000000000000000000000000085ee99d6a97c76d6b87ed12e998dd", - "0x00000000000000000000000000000019fa1cc7006ec07a362874e5899347d3b5", - "0x00000000000000000000000000000000002dd21ac74693f12eae15e19ac3f4e9", - "0x0000000000000000000000000000005a1ea35dfbcf743b3ce11ce2e8629f19e6", - "0x00000000000000000000000000000000002fa64b3bd8b9921723317b2b3bc016", - "0x00000000000000000000000000000000c8749e8b44fbafa0cb783908f71ca43c", - "0x00000000000000000000000000000000000452edc05eda610ee588e3bf496292", - "0x000000000000000000000000000000d9780c71504a1870651ec671b124a36f6f", - "0x00000000000000000000000000000000002e594354b67060c97f311225fa34ae", - "0x000000000000000000000000000000170753b4fb55d2a839346eaa20855c2ce7", - "0x000000000000000000000000000000000006c3bdda1a4d3ece70c8a57f1f0263", - "0x0000000000000000000000000000003dd4b48e3e37919c109c3b18cc3b2265a7", - "0x0000000000000000000000000000000000152eca2c022ee0e6340d62891c5228", - "0x00000000000000000000000000000027857e742687fcbb8a1776c44fc89bd992", - "0x00000000000000000000000000000000000d43515b1f31d2c281a679e9a60597", - "0x00000000000000000000000000000021a6c141043aba99a2455fe9d3162aea31", - "0x0000000000000000000000000000000000116eca793064aa52816099d7b1b856", - "0x00000000000000000000000000000080d8af2c3a7eb09247b224d69feb59db7f", - "0x00000000000000000000000000000000000cdc3dc774bc9cf885f22340c55e34", - "0x0000000000000000000000000000009b3dce5761fcef7f34b7daefcac691acfc", - "0x0000000000000000000000000000000000175cc08fc63b1b7e3d01ac07be17ba", - "0x0000000000000000000000000000000fdb0290862616c081ab8bcf9871c309c2", - "0x00000000000000000000000000000000002bff3e69b075b3aa3104ab8b4b0c55", - "0x0000000000000000000000000000003b79cb77993965a3aadd9ca90e23180bdf", - "0x00000000000000000000000000000000002b82418b647333b049ddb4a0f00036", - "0x0000000000000000000000000000003ee1123375c63e3aa50d9b10730a110f2b", - "0x000000000000000000000000000000000029a5aef768ee4d574df39792435c39", - "0x000000000000000000000000000000b04cfb4ff8a6a6f75c3c12e7c3907fe47c", - "0x000000000000000000000000000000000007e07a88f0efa047b6d1159e5433c6", - "0x0000000000000000000000000000000380f8a411e8cd6729fc91b78f0a7e30e4", - "0x00000000000000000000000000000000002c12b6bf8709a904fa3125c44e700f", - "0x000000000000000000000000000000cd7ca3e9ed8bb9a6121f522023dfa8b26e", - "0x0000000000000000000000000000000000283538b42da44b4bec7290be552dfd", - "0x000000000000000000000000000000662f3ca47840d128223a7eccf2f8bfdc96", - "0x000000000000000000000000000000000024d658e9e6acb83221331c656807d3", - "0x000000000000000000000000000000f85d8aab4282d54e5f0eeb7c2135fd427a", - "0x00000000000000000000000000000000002599d73eb9093c7a13848d307874a0", - "0x000000000000000000000000000000ff7ddb01808894d4e1f81d238eb5869363", - "0x00000000000000000000000000000000000ae65f87c37152d4c5e012874d5bf0", - "0x0000000000000000000000000000006793e0f1bf87ca4917287881df03901ad7", - "0x000000000000000000000000000000000005e93e00058f2566596a419f9dc5ce", - "0x000000000000000000000000000000767da639e35d5d1ef71478a950cf288513", - "0x00000000000000000000000000000000002afd252e8615e7eeda46b48225961d", - "0x0000000000000000000000000000007def46ee76f6ea569e02646c04537d31e0", - "0x00000000000000000000000000000000001fe6504150f81283f95b42498506a4", - "0x000000000000000000000000000000a4c1f600b7652e539371dc66a0e235337d", - "0x00000000000000000000000000000000000b101b006770c17530fa8330b6dc04", - "0x00000000000000000000000000000074377052aa69f94a755cde3f9ce8138ce2", - "0x0000000000000000000000000000000000165266c7414a3b474914dba91316bd", - "0x000000000000000000000000000000a8ed603c54c796e5ec3c7cc3caa2d33449", - "0x0000000000000000000000000000000000043a3877cf735247a6a67190477bea", - "0x000000000000000000000000000000d63cbc50845d49f0709bb8eff860f4a382", - "0x0000000000000000000000000000000000270e1c50ec474ac2fd022ba73c40f2" + "0x000000000000000000000000000000d0d50af0bddcab0ed97122701d58270068", + "0x00000000000000000000000000000000000277e40a68ec404b450c141bb5d040", + "0x00000000000000000000000000000044addfcb623a146bc81a6e5523cf95b731", + "0x000000000000000000000000000000000004cf2654c61618fba84e111562cad2" ] - hash = "0x1f58925ff616b4fd1e9957536f379ea1a3a79bad46033bd094797cf1000f5fa4" + hash = "0x18c18e28746f7afc61052aa0f79002f5318e982f8b0faa6cb15ed24574325531" diff --git a/noir-projects/noir-protocol-circuits/crates/types/src/abis/block_constant_data.nr b/noir-projects/noir-protocol-circuits/crates/types/src/abis/block_constant_data.nr index 45772eeb1d19..a0d54a59a610 100644 --- a/noir-projects/noir-protocol-circuits/crates/types/src/abis/block_constant_data.nr +++ b/noir-projects/noir-protocol-circuits/crates/types/src/abis/block_constant_data.nr @@ -8,10 +8,10 @@ use std::meta::derive; pub struct BlockConstantData { // Archive tree snapshot at the very beginning of the entire block. pub last_archive: AppendOnlyTreeSnapshot, - // L1-to-L2 message tree snapshot after this block lands. - // For the first block in a checkpoint, this should be the snapshot after inserting the new l1-to-l2 message subtree - // into the last l1-to-l2 tree snapshot in `last_archive`. - // For subsequent blocks, this should match the snapshot of the previous block. + // L1-to-L2 message tree snapshot after this block's own message bundle has been inserted. The AVM validates this + // block's l1-to-l2 message read requests against it, so a tx in this block can read the messages this block + // inserts (same-block consumption). Every block-root variant that carries txs asserts this equals its computed + // post-bundle root, whether or not the block is the first in its checkpoint. pub l1_to_l2_tree_snapshot: AppendOnlyTreeSnapshot, pub vk_tree_root: Field, pub protocol_contracts_hash: Field, diff --git a/noir-projects/noir-protocol-circuits/crates/types/src/abis/checkpoint_header.nr b/noir-projects/noir-protocol-circuits/crates/types/src/abis/checkpoint_header.nr index 95ba92af8da8..59cb06c87a07 100644 --- a/noir-projects/noir-protocol-circuits/crates/types/src/abis/checkpoint_header.nr +++ b/noir-projects/noir-protocol-circuits/crates/types/src/abis/checkpoint_header.nr @@ -15,6 +15,10 @@ pub struct CheckpointHeader { pub block_headers_hash: Field, pub blobs_hash: Field, pub in_hash: Field, + // Inbox rolling-hash chain value after consuming all L1-to-L2 messages bundled into this checkpoint. It is the + // dual of `in_hash` (AZIP-22 Fast Inbox): the truncated-to-field sha256 chain the L1 Inbox accumulates. Currently a + // pass-through commitment; `in_hash` remains the authoritative L1 check until the Fast Inbox flip. + pub inbox_rolling_hash: Field, // The root of the epoch out hash balanced tree. The out hash of the first checkpoint in the epoch is inserted at // index 0, the second at index 1, and so on. // Note: This is not necessarily the final epoch out hash. It includes only the out hashes of checkpoints up to and @@ -40,6 +44,7 @@ impl Empty for CheckpointHeader { block_headers_hash: 0, blobs_hash: 0, in_hash: 0, + inbox_rolling_hash: 0, epoch_out_hash: 0, slot_number: 0, timestamp: 0, @@ -58,6 +63,7 @@ impl CheckpointHeader { let block_headers_hash_bytes: [u8; 32] = self.block_headers_hash.to_be_bytes(); let blobs_hash_bytes: [u8; 32] = self.blobs_hash.to_be_bytes(); let in_hash_bytes: [u8; 32] = self.in_hash.to_be_bytes(); + let inbox_rolling_hash_bytes: [u8; 32] = self.inbox_rolling_hash.to_be_bytes(); let epoch_out_hash_bytes: [u8; 32] = self.epoch_out_hash.to_be_bytes(); let slot_number_bytes: [u8; 32] = self.slot_number.to_be_bytes(); let timestamp_bytes: [u8; 8] = (self.timestamp as Field).to_be_bytes(); @@ -78,6 +84,7 @@ impl CheckpointHeader { .concat(block_headers_hash_bytes) .concat(blobs_hash_bytes) .concat(in_hash_bytes) + .concat(inbox_rolling_hash_bytes) .concat(epoch_out_hash_bytes) .concat(slot_number_bytes) .concat(timestamp_bytes) @@ -101,8 +108,7 @@ fn empty_checkpoint_header_hash_matches_ts() { let header = CheckpointHeader::empty(); // Generated from checkpoint_header.test.ts - let empty_checkpoint_header_hash_from_ts = - 0x002e384af86a480f952aa16443fd29646a9063865e62d7c403fc7ed697bb7712; + let empty_checkpoint_header_hash_from_ts = 0x0008c3e5bbea4fba57201a69d4bf70a0d255df921fdef4924c22da087f9338c2; assert_eq(header.hash(), empty_checkpoint_header_hash_from_ts); } @@ -114,6 +120,7 @@ fn checkpoint_header_hash_matches_ts() { block_headers_hash: 456, blobs_hash: 77, in_hash: 88, + inbox_rolling_hash: 89, epoch_out_hash: 99, slot_number: 1234, timestamp: 5678, @@ -130,8 +137,7 @@ fn checkpoint_header_hash_matches_ts() { assert_eq(deserialized, header); // Generated from checkpoint_header.test.ts - let checkpoint_header_hash_from_ts = - 0x00d0dc440023ae006b0880b29ebfd5fda599d1aa7707f925229a362c5f24f3fc; + let checkpoint_header_hash_from_ts = 0x00519b87177a8a5e4edd03f4d820aec6d402497ef1ab70e2ecd4d4c39b339611; assert_eq(header.hash(), checkpoint_header_hash_from_ts); } @@ -145,6 +151,7 @@ fn checkpoint_header_hash_large_values_matches_ts() { block_headers_hash: MAX_FIELD_VALUE - 456, blobs_hash: MAX_FIELD_VALUE - 77, in_hash: MAX_FIELD_VALUE - 88, + inbox_rolling_hash: MAX_FIELD_VALUE - 89, epoch_out_hash: MAX_FIELD_VALUE - 99, slot_number: MAX_FIELD_VALUE - 1234, timestamp: MAX_U64_VALUE - 5678, @@ -163,8 +170,7 @@ fn checkpoint_header_hash_large_values_matches_ts() { assert_eq(deserialized, header); // Generated from checkpoint_header.test.ts - let checkpoint_header_hash_large_values_from_ts = - 0x0077f763e5840cc3f24686ac79f58ef8a7f08c6418fd757e7e84566dc2eb032a; + let checkpoint_header_hash_large_values_from_ts = 0x00d64307fa93c32ae46a4c3b6a1911d31994daa8d11d50201f0086a6cbaa9bac; assert_eq(header.hash(), checkpoint_header_hash_large_values_from_ts); } diff --git a/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr b/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr index 0da946df4b89..5568ccbfc8c2 100644 --- a/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr +++ b/noir-projects/noir-protocol-circuits/crates/types/src/constants.nr @@ -63,6 +63,12 @@ pub global NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH: u32 = NULLIFIER_TREE_HEIGHT - NULLIFIER_SUBTREE_HEIGHT; pub global L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH: u32 = L1_TO_L2_MSG_TREE_HEIGHT - L1_TO_L2_MSG_SUBTREE_HEIGHT; +// Cap on L1-to-L2 messages bundled into a single L2 block. Transitional value equal to the per-checkpoint cap: the +// constant is deliberately oversized so the first block's bundle can carry a whole checkpoint's padded messages during +// the transition, and drops to 256 at the flip. +pub global MAX_L1_TO_L2_MSGS_PER_BLOCK: u32 = 1024; +// Cap on L1-to-L2 messages consumed by a single checkpoint. Semantically today's NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP. +pub global MAX_L1_TO_L2_MSGS_PER_CHECKPOINT: u32 = 1024; // Maximum number of subtrees a L2ToL1Msg unbalanced tree can have. Used when calculating the out hash of a tx. pub global MAX_L2_TO_L1_MSG_SUBTREES_PER_TX: u32 = 3; // ceil(log2(MAX_L2_TO_L1_MSGS_PER_TX)) @@ -123,8 +129,8 @@ pub global CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP_VK_INDEX: u32 = 17; pub global CHECKPOINT_PADDING_ROLLUP_VK_INDEX: u32 = 18; pub global CHECKPOINT_MERGE_ROLLUP_VK_INDEX: u32 = 19; pub global ROOT_ROLLUP_VK_INDEX: u32 = 20; -pub global PARITY_BASE_VK_INDEX: u32 = 21; -pub global PARITY_ROOT_VK_INDEX: u32 = 22; +// VK indices 21 and 22 are intentionally unallocated: they were the parity base / parity root, replaced by the +// InboxParity size ladder (appended at 74-76 below, since the reset range 23-64 is reserved). // The three families below carve up the reset-family range (23-42). Each base is the VK index // of its family's first variant; subsequent variants occupy successive indices. Bases must // stay ascending; `validate_vk_in_vk_tree` depends on this ordering. @@ -147,6 +153,14 @@ pub global PRIVATE_KERNEL_INNER_2_VK_INDEX: u32 = 69; pub global PRIVATE_KERNEL_INNER_3_VK_INDEX: u32 = 70; pub global PRIVATE_KERNEL_INNER_4_VK_INDEX: u32 = 71; pub global PRIVATE_KERNEL_INNER_5_VK_INDEX: u32 = 72; +// The block-root variants at 10-14 are full; the non-first message-only block root is appended after the +// multi-app kernel indices (65-72), since 43-64 are reserved for reset variants. +pub global BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX: u32 = 73; +// The InboxParity size ladder: one VK per size, checked as an allowed set by the checkpoint root. Appended here +// (rather than reusing the freed 21/22) so the three sizes stay contiguous and read in order. +pub global INBOX_PARITY_64_VK_INDEX: u32 = 74; +pub global INBOX_PARITY_256_VK_INDEX: u32 = 75; +pub global INBOX_PARITY_1024_VK_INDEX: u32 = 76; // Maximum number of apps absorbed by a single private kernel iteration. pub global MAX_APPS_PER_KERNEL: u32 = 5; @@ -347,6 +361,7 @@ pub global GLOBAL_VARIABLES_LENGTH: u32 = 7 + GAS_FEES_LENGTH; pub global APPEND_ONLY_TREE_SNAPSHOT_LENGTH: u32 = 2; pub global APPEND_ONLY_TREE_SNAPSHOT_LENGTH_BYTES: u32 = 36; pub global SPONGE_BLOB_LENGTH: u32 = 10; +pub global L1_TO_L2_MESSAGE_SPONGE_LENGTH: u32 = 10; pub global BLS12_FR_LIMBS: u32 = 3; // TODO(#14646): get this from bignum pub global BLS12_FQ_LIMBS: u32 = 4; // TODO(#14646): get this from bignum pub global BLS12_POINT_LENGTH: u32 = 2 * BLS12_FQ_LIMBS + 1; // TODO(#14646): reduce num fields needed here? @@ -435,6 +450,7 @@ pub global CHECKPOINT_HEADER_LENGTH: u32 = 1 /* last_archive_root */ + 1 /* block_headers_hash */ + 1 /* blobs_hash */ + 1 /* in_hash */ + + 1 /* inbox_rolling_hash */ + 1 /* out_hash */ + 1 /* slot_number */ + 1 /* timestamp */ @@ -621,20 +637,25 @@ pub global BLOCK_ROLLUP_PUBLIC_INPUTS_LENGTH: u32 = CHECKPOINT_CONSTANT_DATA_LEN + 2 * SPONGE_BLOB_LENGTH /* start_sponge_blob and end_sponge_blob */ + 1 /* timestamp */ + 1 /* block_headers_hash */ - + 1 /* in_hash */ + + 1 /* is_first_block */ + + 2 * L1_TO_L2_MESSAGE_SPONGE_LENGTH /* start_msg_sponge and end_msg_sponge */ + 1 /* out_hash */ + 1 /* accumulated_fees */ + 1 /* accumulated_mana_used */; pub global CHECKPOINT_ROLLUP_PUBLIC_INPUTS_LENGTH: u32 = EPOCH_CONSTANT_DATA_LENGTH + 2 * APPEND_ONLY_TREE_SNAPSHOT_LENGTH /* previous_archive and new_archive */ - + MAX_CHECKPOINTS_PER_EPOCH /* checkpoint_header_hashes */ + 2 * APPEND_ONLY_TREE_SNAPSHOT_LENGTH /* start_out_hash and end_out_hash */ + + 1 /* start_inbox_rolling_hash */ + + 1 /* end_inbox_rolling_hash */ + + MAX_CHECKPOINTS_PER_EPOCH /* checkpoint_header_hashes */ + MAX_CHECKPOINTS_PER_EPOCH * FEE_RECIPIENT_LENGTH /* fees */ + 2 * BLOB_ACCUMULATOR_LENGTH /* start and end blob accumulators */ + FINAL_BLOB_BATCHING_CHALLENGES_LENGTH; pub global ROOT_ROLLUP_PUBLIC_INPUTS_LENGTH: u32 = 1 /* previous_archive_root */ + 1 /* end_archive_root */ + 1 /* out_hash */ + + 1 /* previous_inbox_rolling_hash */ + + 1 /* end_inbox_rolling_hash */ + 1 /* chain_id */ + 1 /* version */ + 1 /* vk_tree_root */ @@ -644,10 +665,16 @@ pub global ROOT_ROLLUP_PUBLIC_INPUTS_LENGTH: u32 = 1 /* previous_archive_root */ + MAX_CHECKPOINTS_PER_EPOCH * FEE_RECIPIENT_LENGTH /* fees */ + FINAL_BLOB_ACCUMULATOR_LENGTH /* blob_public_inputs */; -// Depends on the final number of messages per checkpoint. +// The InboxParity size ladder: one variable-size parity proof is produced per checkpoint, and the prover picks the +// smallest size >= the checkpoint's real message count. The largest rung equals the per-checkpoint message cap. +pub global INBOX_PARITY_SIZE_SMALL: u32 = 64; +pub global INBOX_PARITY_SIZE_MEDIUM: u32 = 256; +pub global INBOX_PARITY_SIZE_LARGE: u32 = 1024; + +// Fan-in of the sha256 `in_hash` frontier tree (NUM_BASE_PARITY_PER_ROOT_PARITY * NUM_MSGS_PER_BASE_PARITY == +// NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP). The circuits no longer build this tree, but the constants are still consumed +// by the generated Solidity `Constants` and the L1 `Parity.t.sol` test that checks the frontier-root construction. pub global NUM_MSGS_PER_BASE_PARITY: u32 = 256; -// pub global NUM_BASE_PARITY_PER_ROOT_PARITY: u32 = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP / NUM_MSGS_PER_BASE_PARITY; -// FIX: Sadly, writing this as above causes a type error in type_conversion.ts. pub global NUM_BASE_PARITY_PER_ROOT_PARITY: u32 = 4; // Lengths of the different types of proofs in fields @@ -1411,9 +1438,9 @@ mod test { use crate::merkle_tree::root::compute_empty_sha_tree_root; use crate::traits::ToField; use super::{ - GLOBAL_INDEX_CONTRACT_MIN_REVERTIBLE_SIDE_EFFECT_COUNTER_OFFSET, MAX_ETH_ADDRESS_VALUE, - NUM_BASE_PARITY_PER_ROOT_PARITY, NUM_MSGS_PER_BASE_PARITY, - NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL, + GLOBAL_INDEX_CONTRACT_MIN_REVERTIBLE_SIDE_EFFECT_COUNTER_OFFSET, INBOX_PARITY_SIZE_LARGE, + MAX_ETH_ADDRESS_VALUE, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, + TOTAL_COUNTED_SIDE_EFFECTS_PER_CALL, }; #[test] @@ -1458,10 +1485,8 @@ mod test { #[test] fn parity_covers_all_l1_to_l2_msgs() { - assert_eq( - NUM_BASE_PARITY_PER_ROOT_PARITY * NUM_MSGS_PER_BASE_PARITY, - NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, - ); + // The largest InboxParity rung must be able to hold a full checkpoint's worth of messages. + assert_eq(INBOX_PARITY_SIZE_LARGE, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP); } #[test] diff --git a/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/append_only_tree.nr b/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/append_only_tree.nr index 4cd8804ddbe0..757d1941ea08 100644 --- a/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/append_only_tree.nr +++ b/noir-projects/noir-protocol-circuits/crates/types/src/merkle_tree/append_only_tree.nr @@ -5,6 +5,7 @@ use crate::{ merkle_tree::{merkle_hash, sha_merkle_hash}, root::{compute_empty_tree_root_with_hasher, root_from_sibling_path_with_hasher}, }, + utils::arrays::assert_trailing_zeros, }; pub fn append_leaf_to_snapshot( @@ -104,6 +105,150 @@ pub fn insert_subtree_root_to_snapshot_with_hasher( + snapshot: AppendOnlyTreeSnapshot, + leaves: [Field; MaxLeaves], + num_leaves: u32, + frontier_hint: [Field; TreeHeight], +) -> AppendOnlyTreeSnapshot { + // We cast the leaf index to a u64, so heights above 64 would insert at the wrong index once the tree grows past + // 2^64 leaves. Checking at compile time turns a bad instantiation into a build error rather than a circuit no + // prover can satisfy. + std::static_assert( + TreeHeight <= 64, + "`append_leaves_to_snapshot` does not support trees with height greater than 64", + ); + assert(num_leaves <= MaxLeaves, "num_leaves is greater than the leaves array length"); + // Hint lanes past `num_leaves` must be zero so they cannot smuggle values into anything a caller later absorbs. + assert_trailing_zeros(leaves, num_leaves); + + // `zero_subtree_roots[level]` is the root of an all-zero subtree of height `level`; index 0 is the empty leaf, 0. + let mut zero_subtree_roots = [0; TreeHeight]; + for level in 1..TreeHeight { + zero_subtree_roots[level] = + merkle_hash(zero_subtree_roots[level - 1], zero_subtree_roots[level - 1]); + } + + // The cast below truncates, so an index above 2^64 would silently drop its high bits and append at the wrong + // position. Callers keep the index far below that by only ever advancing it by the number of leaves appended, but + // nothing in this function's signature enforces it, so pin it here. + snapshot.next_available_leaf_index.assert_max_bit_size::<64>(); + let start_index = snapshot.next_available_leaf_index as u64; + let end_index = start_index + num_leaves as u64; + // Guard against wrapping past the tree capacity, which would otherwise silently produce a wrong root. + let mut tree_is_filled_exactly = false; + if TreeHeight < 64 { + let capacity = 1 as u64 << TreeHeight as u64; + assert(end_index <= capacity, "append_leaves_to_snapshot exceeds the tree capacity"); + tree_is_filled_exactly = end_index == capacity; + } + + // Validate the hint pins to the snapshot: recompute the root of a tree holding `start_index` leaves from the hint's + // left siblings and the zero subtrees to the right. + assert( + recompute_root_from_frontier(frontier_hint, zero_subtree_roots, start_index) + == snapshot.root, + "Frontier hint does not match the snapshot root", + ); + + // Merge the batch into the frontier one level at a time. At each level, `working` holds the batch's nodes, + // starting at absolute position `s` with `c` real entries (lanes past `c` hold garbage that is never read): + // - If `s` is odd the batch starts as a right child, so its pending left sibling — the validated hint entry — is + // prepended via a mux shift (no hashes) to make the batch start even. + // - If the count is then odd, the dangling last node sits at an even position: it is the level's new pending left + // child, so it becomes the frontier entry and drops out of pairing. On an even count the old entry is left in + // place; at the new tree size it is unused garbage, just like unread hint lanes. + // - The remaining nodes are hashed pairwise into the next level. + let mut frontier = frontier_hint; + let mut working = [0; MaxLeaves + 2]; + for i in 0..MaxLeaves { + working[i] = leaves[i]; + } + let mut s = start_index; + let mut c = num_leaves; + for level in 0..TreeHeight { + let prepend = (s % 2 == 1) & (c != 0); + let mut shifted = [0; MaxLeaves + 2]; + shifted[0] = if prepend { frontier[level] } else { working[0] }; + // The loop bounds below only need to upper-bound the batch size at this level; the shift amounts are clamped + // below 32 because a u32 shift by 32+ does not const-fold, and `MaxLeaves >> 31` is already 0. + for j in 1..(MaxLeaves >> std::cmp::min(level, 31)) + 2 { + shifted[j] = if prepend { working[j - 1] } else { working[j] }; + } + let s2 = s - prepend as u64; + let c2 = c + prepend as u32; + + // `c2 - 1` is only meaningful when `c2` is odd (hence >= 1); the subtraction is kept unconditionally safe. + let dangling_index = c2 - (c2 != 0) as u32; + frontier[level] = if c2 % 2 == 1 { + shifted[dangling_index] + } else { + frontier[level] + }; + + for i in 0..(MaxLeaves >> std::cmp::min(level + 1, 31)) + 1 { + working[i] = merkle_hash(shifted[2 * i], shifted[2 * i + 1]); + } + s = s2 / 2; + c = c2 / 2; + } + + // The frontier is now the end-state frontier, so the final root falls out of the same recomputation used to + // validate the hint. The exception is an append that fills the tree exactly: a full tree has no representable + // frontier, but in that case the batch was merged all the way up and `working[0]` is the root itself. + let root = if num_leaves == 0 { + snapshot.root + } else if tree_is_filled_exactly { + working[0] + } else { + recompute_root_from_frontier(frontier, zero_subtree_roots, end_index) + }; + + AppendOnlyTreeSnapshot { + root, + next_available_leaf_index: snapshot.next_available_leaf_index + num_leaves as Field, + } +} + +/// Recomputes the root of an append-only tree that holds `index` leaves (positions `0..index` filled, the rest zero) +/// from its frontier of left siblings and the all-zero subtree roots to the right. +fn recompute_root_from_frontier( + frontier: [Field; TreeHeight], + zero_subtree_roots: [Field; TreeHeight], + index: u64, +) -> Field { + let mut node = 0; // the empty leaf sitting at `index` + let mut idx = index; + for level in 0..TreeHeight { + node = if idx % 2 == 0 { + merkle_hash(node, zero_subtree_roots[level]) + } else { + merkle_hash(frontier[level], node) + }; + idx = idx / 2; + } + node +} + mod tests { use crate::{ abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot, @@ -304,3 +449,315 @@ mod tests { let _ = insert_subtree_root_to_snapshot::<64, 64>(empty_snapshot, sibling_path, 0); } } + +mod append_leaves_tests { + use crate::{ + abis::append_only_tree_snapshot::AppendOnlyTreeSnapshot, + merkle_tree::{ + compute_empty_tree_root, + merkle_tree::{merkle_hash, MerkleTree}, + test_utils::compute_zero_hashes, + }, + utils::arrays::subarray, + }; + use super::{append_leaves_to_snapshot, insert_subtree_root_to_snapshot}; + + fn padded(items: [Field; N]) -> [Field; M] { + let mut out = [0; M]; + for i in 0..N { + out[i] = items[i]; + } + out + } + + fn empty_snapshot() -> AppendOnlyTreeSnapshot { + AppendOnlyTreeSnapshot { + root: compute_empty_tree_root::(), + next_available_leaf_index: 0, + } + } + + #[test] + fn append_empty_bundle_is_noop() { + let snapshot = empty_snapshot::<5>(); + let result = append_leaves_to_snapshot::<5, 8>(snapshot, [0; 8], 0, [0; 5]); + assert_eq(result, snapshot); + } + + #[test] + fn append_single_leaf() { + let snapshot = empty_snapshot::<5>(); + let leaves: [Field; 8] = padded([42]); + let result = append_leaves_to_snapshot::<5, 8>(snapshot, leaves, 1, [0; 5]); + + let expected_root = MerkleTree::<32>::new(padded([42])).get_root(); + assert_eq(result.root, expected_root); + assert_eq(result.next_available_leaf_index, 1); + } + + #[test] + fn append_at_non_aligned_index() { + // Tree already holds 3 leaves, so the next index (3) is not aligned to any power-of-two boundary. + let before_root = MerkleTree::<32>::new(padded([11, 22, 33])).get_root(); + let snapshot = AppendOnlyTreeSnapshot { root: before_root, next_available_leaf_index: 3 }; + // Frontier at index 3: level 0 left sibling is leaf 2 (33), level 1 left sibling is hash(leaf0, leaf1). + // Higher levels are left children at index 3, so their hint entries are unused (and left zero). + let frontier = [33, merkle_hash(11, 22), 0, 0, 0]; + + let new_leaves: [Field; 8] = padded([44, 55]); + let result = append_leaves_to_snapshot::<5, 8>(snapshot, new_leaves, 2, frontier); + + let expected_root = MerkleTree::<32>::new(padded([11, 22, 33, 44, 55])).get_root(); + assert_eq(result.root, expected_root); + assert_eq(result.next_available_leaf_index, 5); + } + + #[test] + fn append_max_size_bundle() { + let snapshot = empty_snapshot::<5>(); + let leaves = [101, 102, 103, 104, 105, 106, 107, 108]; + let result = append_leaves_to_snapshot::<5, 8>(snapshot, leaves, 8, [0; 5]); + + let expected_root = MerkleTree::<32>::new(padded(leaves)).get_root(); + assert_eq(result.root, expected_root); + assert_eq(result.next_available_leaf_index, 8); + } + + #[test] + fn append_partial_bundle_skips_padding_lanes() { + let snapshot = empty_snapshot::<5>(); + let leaves: [Field; 8] = padded([11, 22, 33]); + let result = append_leaves_to_snapshot::<5, 8>(snapshot, leaves, 3, [0; 5]); + + let expected_root = MerkleTree::<32>::new(padded([11, 22, 33])).get_root(); + assert_eq(result.root, expected_root); + assert_eq(result.next_available_leaf_index, 3); + } + + #[test] + fn append_matches_subtree_insert_small() { + // Appending 8 compact leaves at aligned index 0 reproduces inserting a height-3 subtree of the same leaves. + let snapshot = empty_snapshot::<5>(); + let leaves = [101, 102, 103, 104, 105, 106, 107, 108]; + + let subtree_root = MerkleTree::<8>::new(leaves).get_root(); + let sibling_path: [Field; 2] = subarray(compute_zero_hashes::<5>(), 2); + let ref_snapshot = + insert_subtree_root_to_snapshot::<5, 3>(snapshot, sibling_path, subtree_root); + + let leaves8: [Field; 8] = leaves; + let app_snapshot = append_leaves_to_snapshot::<5, 8>(snapshot, leaves8, 8, [0; 5]); + + assert_eq(app_snapshot, ref_snapshot); + } + + #[test] + fn append_matches_subtree_insert_1024() { + // The transitional first-block scenario: appending a full 1024-leaf bundle at aligned index 0 into the + // production-height (36) tree must reproduce today's fixed height-10 subtree insertion bit-for-bit. + let mut leaves = [0; 1024]; + for i in 0..1024 { + leaves[i] = (i + 1) as Field; + } + + let snapshot = empty_snapshot::<36>(); + + let subtree_root = MerkleTree::<1024>::new(leaves).get_root(); + let sibling_path: [Field; 26] = subarray(compute_zero_hashes::<36>(), 9); + let ref_snapshot = + insert_subtree_root_to_snapshot::<36, 10>(snapshot, sibling_path, subtree_root); + + let app_snapshot = append_leaves_to_snapshot::<36, 1024>(snapshot, leaves, 1024, [0; 36]); + + // Both paths produce root 0x27b87d4d3b78d1fc49a6cb4d83e0cc81de7f5972cda7fe29a6a82aa2c255cb3d. + assert_eq(app_snapshot.root, ref_snapshot.root); + assert_eq(app_snapshot.next_available_leaf_index, 1024); + } + + #[test(should_fail_with = "Frontier hint does not match the snapshot root")] + fn append_wrong_frontier_hint_fails() { + let before_root = MerkleTree::<32>::new(padded([11, 22, 33])).get_root(); + let snapshot = AppendOnlyTreeSnapshot { root: before_root, next_available_leaf_index: 3 }; + // Corrupt a pinned frontier entry (level 0), which the root recomputation must reject. + let frontier = [34, merkle_hash(11, 22), 0, 0, 0]; + + let new_leaves: [Field; 8] = padded([44, 55]); + let _ = append_leaves_to_snapshot::<5, 8>(snapshot, new_leaves, 2, frontier); + } + + #[test] + fn append_ignores_unpinned_frontier_lanes() { + // At start index 3 only levels 0 and 1 are right children, so those are the only hint lanes the validation + // reads; the rest are unpinned and entirely prover-chosen. A tree database answering with a sibling path puts + // the zero-subtree roots there, while the tests here pass zeros. Neither may influence the result. + let before_root = MerkleTree::<32>::new(padded([11, 22, 33])).get_root(); + let snapshot = AppendOnlyTreeSnapshot { root: before_root, next_available_leaf_index: 3 }; + let new_leaves: [Field; 8] = padded([44, 55]); + let expected_root = MerkleTree::<32>::new(padded([11, 22, 33, 44, 55])).get_root(); + + // `compute_zero_hashes[i]` is the root of an all-zero subtree of height `i + 1`, i.e. the right sibling a + // sibling path carries at level `i + 1`. + let zero_hashes = compute_zero_hashes::<5>(); + let from_db = [33, merkle_hash(11, 22), zero_hashes[1], zero_hashes[2], zero_hashes[3]]; + let adversarial = [33, merkle_hash(11, 22), 0xdead, 0xbeef, 0xf00d]; + + let from_db_result = append_leaves_to_snapshot::<5, 8>(snapshot, new_leaves, 2, from_db); + assert_eq(from_db_result.root, expected_root); + assert_eq(from_db_result.next_available_leaf_index, 5); + + let junk_result = append_leaves_to_snapshot::<5, 8>(snapshot, new_leaves, 2, adversarial); + assert_eq(junk_result.root, expected_root); + assert_eq(junk_result.next_available_leaf_index, 5); + } + + #[test] + fn append_reuses_stale_pinned_frontier_entry() { + // Appending one leaf at index 5 leaves level 2 untouched by the merge: the batch has no node there. The final + // root recomputation still reads that entry, because the end index 6 is a right child at level 2. The reuse is + // sound only because the start index 5 is a right child at level 2 as well, so the entry is pinned. + let before_root = MerkleTree::<32>::new(padded([11, 22, 33, 44, 55])).get_root(); + let snapshot = AppendOnlyTreeSnapshot { root: before_root, next_available_leaf_index: 5 }; + let level_2_node = merkle_hash(merkle_hash(11, 22), merkle_hash(33, 44)); + let frontier = [55, 0, level_2_node, 0, 0]; + + let new_leaves: [Field; 8] = padded([66]); + let result = append_leaves_to_snapshot::<5, 8>(snapshot, new_leaves, 1, frontier); + + let expected_root = MerkleTree::<32>::new(padded([11, 22, 33, 44, 55, 66])).get_root(); + assert_eq(result.root, expected_root); + assert_eq(result.next_available_leaf_index, 6); + } + + #[test(should_fail_with = "Frontier hint does not match the snapshot root")] + fn append_wrong_stale_pinned_frontier_entry_fails() { + // The level-2 entry that `append_reuses_stale_pinned_frontier_entry` reuses is pinned, so corrupting it is + // rejected instead of silently producing a wrong root. + let before_root = MerkleTree::<32>::new(padded([11, 22, 33, 44, 55])).get_root(); + let snapshot = AppendOnlyTreeSnapshot { root: before_root, next_available_leaf_index: 5 }; + let level_2_node = merkle_hash(merkle_hash(11, 22), merkle_hash(33, 44)); + let frontier = [55, 0, level_2_node + 1, 0, 0]; + + let new_leaves: [Field; 8] = padded([66]); + let _ = append_leaves_to_snapshot::<5, 8>(snapshot, new_leaves, 1, frontier); + } + + #[test] + fn append_filling_tree_exactly() { + // Filling the last four leaves of a height-4 tree takes the exact-fill branch: the post-state has no + // representable frontier, so the root comes from the top of the merged batch instead of a recomputation. + // Levels 0 and 1 are left children at index 12, so their junk hint lanes must not reach the result. + let mut pre_leaves = [0; 16]; + for i in 0..12 { + pre_leaves[i] = (100 + i) as Field; + } + let pre_tree = MerkleTree::new(pre_leaves); + let snapshot = + AppendOnlyTreeSnapshot { root: pre_tree.get_root(), next_available_leaf_index: 12 }; + // Levels 2 and 3 are right children at index 12: the node over leaves 8..11 and the node over leaves 0..7. + let level_2_node = merkle_hash(merkle_hash(108, 109), merkle_hash(110, 111)); + let left_half = MerkleTree::<8>::new([100, 101, 102, 103, 104, 105, 106, 107]); + let frontier = [0xdead, 0xbeef, level_2_node, left_half.get_root()]; + + let batch: [Field; 6] = padded([201, 202, 203, 204]); + let result = append_leaves_to_snapshot::<4, 6>(snapshot, batch, 4, frontier); + + let mut all_leaves = pre_leaves; + for i in 0..4 { + all_leaves[12 + i] = (201 + i) as Field; + } + assert_eq(result.root, MerkleTree::new(all_leaves).get_root()); + assert_eq(result.next_available_leaf_index, 16); + } + + #[test(should_fail_with = "append_leaves_to_snapshot exceeds the tree capacity")] + fn append_past_tree_capacity_fails() { + // A height-4 tree holds 16 leaves, so appending 3 from index 14 overruns it. The capacity check runs before + // the hint validation, hence the all-zero frontier here. + let mut pre_leaves = [0; 16]; + for i in 0..14 { + pre_leaves[i] = (100 + i) as Field; + } + let pre_tree = MerkleTree::new(pre_leaves); + let snapshot = + AppendOnlyTreeSnapshot { root: pre_tree.get_root(), next_available_leaf_index: 14 }; + + let batch: [Field; 6] = padded([201, 202, 203]); + let _ = append_leaves_to_snapshot::<4, 6>(snapshot, batch, 3, [0; 4]); + } + + #[test(should_fail_with = "Found non-zero field after breakpoint")] + fn append_non_zero_padding_lane_fails() { + let snapshot = empty_snapshot::<5>(); + // num_leaves is 1, but a later lane carries a non-zero value. + let leaves = [42, 0, 99, 0, 0, 0, 0, 0]; + let _ = append_leaves_to_snapshot::<5, 8>(snapshot, leaves, 1, [0; 5]); + } + + /// Extracts the frontier at `index` from a height-4 reference tree: the node at each level's position + /// `(index >> level) - 1` when that position is odd, i.e. the pending left sibling. + unconstrained fn frontier_of_height_4_tree(tree: MerkleTree<16>, index: u32) -> [Field; 4] { + // Level offsets into `MerkleTree.nodes` for N = 16: level 1 starts at 0, level 2 at 8, level 3 at 12. + let offsets = [0, 8, 12]; + let mut frontier = [0; 4]; + if index % 2 == 1 { + frontier[0] = tree.leaves[index - 1]; + } + for level in 1..4 { + let p = index >> level; + if p % 2 == 1 { + frontier[level] = tree.nodes[offsets[level - 1] + p - 1]; + } + } + frontier + } + + #[test] + unconstrained fn append_exhaustive_small_tree_sweep() { + // Height-4 tree (capacity 16) with MaxLeaves = 6: every (start, num) with start + num <= capacity, compared + // against a reference tree built over the concatenated leaves. Exercises every parity combination of the + // prepend/dangling logic, including appends that fill the tree exactly. + for start in 0..16 { + for num in 0..7 { + if start + num <= 16 { + let mut pre_leaves = [0; 16]; + for i in 0..start { + pre_leaves[i] = (100 + i) as Field; + } + let pre_tree = MerkleTree::new(pre_leaves); + let snapshot = AppendOnlyTreeSnapshot { + root: pre_tree.get_root(), + next_available_leaf_index: start as Field, + }; + let frontier = frontier_of_height_4_tree(pre_tree, start); + + let mut batch = [0; 6]; + let mut all_leaves = pre_leaves; + for i in 0..num { + let value = (200 + start + i) as Field; + batch[i] = value; + all_leaves[start + i] = value; + } + + let result = append_leaves_to_snapshot::<4, 6>(snapshot, batch, num, frontier); + + let expected_tree = MerkleTree::new(all_leaves); + assert_eq(result.root, expected_tree.get_root()); + assert_eq(result.next_available_leaf_index, (start + num) as Field); + } + } + } + } + + #[test(should_fail_with = "Frontier hint does not match the snapshot root")] + fn append_to_completely_full_tree_fails() { + // A full tree has no representable frontier; even a num_leaves = 0 call fails hint validation (fail-closed). + let mut leaves = [0; 16]; + for i in 0..16 { + leaves[i] = (100 + i) as Field; + } + let tree = MerkleTree::new(leaves); + let snapshot = + AppendOnlyTreeSnapshot { root: tree.get_root(), next_available_leaf_index: 16 }; + let _ = append_leaves_to_snapshot::<4, 6>(snapshot, [0; 6], 0, [0; 4]); + } +} diff --git a/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr b/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr index b56b419c225d..7883a04a4f8b 100644 --- a/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr +++ b/noir-projects/noir-protocol-circuits/crates/types/src/poseidon2.nr @@ -23,7 +23,7 @@ impl Poseidon2Sponge { Poseidon2Sponge::hash_internal(input, message_size, message_size != N) } - pub(crate) fn new(iv: Field) -> Poseidon2Sponge { + pub fn new(iv: Field) -> Poseidon2Sponge { let mut result = Poseidon2Sponge { cache: [0; 3], state: [0; 4], cache_size: 0, squeeze_mode: false }; result.state[RATE] = iv; diff --git a/noir-projects/noir-protocol-circuits/pinned-build.tar.gz b/noir-projects/noir-protocol-circuits/pinned-build.tar.gz deleted file mode 100644 index f9f2151659bf..000000000000 Binary files a/noir-projects/noir-protocol-circuits/pinned-build.tar.gz and /dev/null differ diff --git a/playground/vite.config.ts b/playground/vite.config.ts index 203141d50d52..e8b7ad459007 100644 --- a/playground/vite.config.ts +++ b/playground/vite.config.ts @@ -145,9 +145,10 @@ export default defineConfig(({ mode }) => { // - JB: bumped from 1750 => 1800 after adding the `aztec_utl_getTxEffect` oracle handler, which pulls TxEffect / FlatPublicLogs / PrivateLog / PublicDataWrite into the eager PXE import path (#22979). // - 2026-05-12: bumped from 1800 => 1850 after merge-train/barretenberg brought in further bb-side changes (multi-app kernel circuits #23076 etc.) that pushed the main entrypoint to 1801.31 KB, just over the limit raised four days earlier. // - 2026-06-08: bumped from 1850 => 1925 after aztec RPC namespace / client surface changes pushed the main entrypoint to 1872.57 KB on CI (playground cold build). + // - 2026-07-17: bumped from 1925 => 1960 after the fast-inbox per-block L1-to-L2 message bundle changes to the rollup circuit artifacts pushed the main entrypoint to 1936.60 KB on CI. { pattern: /assets\/index-.*\.js$/, - maxSizeKB: 1925, + maxSizeKB: 1960, description: 'Main entrypoint, hard limit', }, // Bump log: diff --git a/yarn-project/archiver/src/test/fake_l1_state.ts b/yarn-project/archiver/src/test/fake_l1_state.ts index 0b9cbcb177f2..d5e5bf6e2197 100644 --- a/yarn-project/archiver/src/test/fake_l1_state.ts +++ b/yarn-project/archiver/src/test/fake_l1_state.ts @@ -628,6 +628,8 @@ export class FakeL1State { index: msg.index, leaf: msg.leaf, rollingHash: msg.rollingHash, + inboxRollingHash: Fr.ZERO, + bucketSeq: 0n, }, })); } @@ -651,6 +653,8 @@ export class FakeL1State { index: msg.index, leaf: msg.leaf, rollingHash: msg.rollingHash, + inboxRollingHash: Fr.ZERO, + bucketSeq: 0n, }, }; } diff --git a/yarn-project/bb-prover/src/honk.ts b/yarn-project/bb-prover/src/honk.ts index 552f7c79beab..6c8f4219a278 100644 --- a/yarn-project/bb-prover/src/honk.ts +++ b/yarn-project/bb-prover/src/honk.ts @@ -3,7 +3,11 @@ import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types export type UltraHonkFlavor = 'ultra_honk' | 'ultra_keccak_honk' | 'ultra_starknet_honk' | 'ultra_rollup_honk'; const UltraKeccakHonkCircuits = ['RootRollupArtifact'] as const satisfies ServerProtocolArtifact[]; -const UltraHonkCircuits = ['ParityBaseArtifact', 'ParityRootArtifact'] as const satisfies ServerProtocolArtifact[]; +const UltraHonkCircuits = [ + 'InboxParity64Artifact', + 'InboxParity256Artifact', + 'InboxParity1024Artifact', +] as const satisfies ServerProtocolArtifact[]; export type UltraKeccakHonkServerProtocolArtifact = (typeof UltraKeccakHonkCircuits)[number]; export type UltraHonkServerProtocolArtifact = (typeof UltraHonkCircuits)[number]; diff --git a/yarn-project/bb-prover/src/prover/server/bb_prover.ts b/yarn-project/bb-prover/src/prover/server/bb_prover.ts index c33794188bc0..ab4855b0f20f 100644 --- a/yarn-project/bb-prover/src/prover/server/bb_prover.ts +++ b/yarn-project/bb-prover/src/prover/server/bb_prover.ts @@ -17,6 +17,8 @@ import { convertBlockRootEmptyTxFirstRollupPrivateInputsToWitnessMap, convertBlockRootFirstRollupOutputsFromWitnessMap, convertBlockRootFirstRollupPrivateInputsToWitnessMap, + convertBlockRootMsgsOnlyRollupOutputsFromWitnessMap, + convertBlockRootMsgsOnlyRollupPrivateInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap, convertBlockRootRollupPrivateInputsToWitnessMap, convertBlockRootSingleTxFirstRollupOutputsFromWitnessMap, @@ -31,10 +33,8 @@ import { convertCheckpointRootRollupPrivateInputsToWitnessMap, convertCheckpointRootSingleBlockRollupOutputsFromWitnessMap, convertCheckpointRootSingleBlockRollupPrivateInputsToWitnessMap, - convertParityBaseOutputsFromWitnessMap, - convertParityBasePrivateInputsToWitnessMap, - convertParityRootOutputsFromWitnessMap, - convertParityRootPrivateInputsToWitnessMap, + convertInboxParityOutputsFromWitnessMap, + convertInboxParityPrivateInputsToWitnessMap, convertPrivateTxBaseRollupOutputsFromWitnessMap, convertPrivateTxBaseRollupPrivateInputsToWitnessMap, convertPublicChonkVerifierOutputsFromWitnessMap, @@ -46,6 +46,7 @@ import { convertTxMergeRollupOutputsFromWitnessMap, convertTxMergeRollupPrivateInputsToWitnessMap, getServerCircuitArtifact, + inboxParityArtifactForSize, } from '@aztec/noir-protocol-circuits-types/server'; import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks'; import { mapProtocolArtifactNameToCircuitName } from '@aztec/noir-protocol-circuits-types/types'; @@ -58,13 +59,14 @@ import { type ServerCircuitProver, makePublicInputsAndRecursiveProof, } from '@aztec/stdlib/interfaces/server'; -import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity'; +import type { InboxParityPrivateInputs, ParityPublicInputs } from '@aztec/stdlib/parity'; import { Proof, RecursiveProof, makeRecursiveProofFromBinary } from '@aztec/stdlib/proofs'; import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, + BlockRootMsgsOnlyRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, @@ -138,34 +140,16 @@ export class BBNativeRollupProver implements ServerCircuitProver { * @param inputs - Inputs to the circuit. * @returns The public inputs of the parity circuit. */ - @trackSpan('BBNativeRollupProver.getBaseParityProof', { [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-base' }) - public getBaseParityProof( - inputs: ParityBasePrivateInputs, + @trackSpan('BBNativeRollupProver.getInboxParityProof', { [Attributes.PROTOCOL_CIRCUIT_NAME]: 'inbox-parity' }) + public getInboxParityProof( + inputs: InboxParityPrivateInputs, ): Promise> { return this.createRecursiveProofAndVerify( inputs, - 'ParityBaseArtifact', + inboxParityArtifactForSize(inputs.size), RECURSIVE_PROOF_LENGTH, - convertParityBasePrivateInputsToWitnessMap, - convertParityBaseOutputsFromWitnessMap, - ); - } - - /** - * Simulates the root parity circuit from its inputs. - * @param inputs - Inputs to the circuit. - * @returns The public inputs of the parity circuit. - */ - @trackSpan('BBNativeRollupProver.getRootParityProof', { [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-root' }) - public getRootParityProof( - inputs: ParityRootPrivateInputs, - ): Promise> { - return this.createRecursiveProofAndVerify( - inputs, - 'ParityRootArtifact', - NESTED_RECURSIVE_PROOF_LENGTH, - convertParityRootPrivateInputsToWitnessMap, - convertParityRootOutputsFromWitnessMap, + convertInboxParityPrivateInputsToWitnessMap, + outputs => convertInboxParityOutputsFromWitnessMap(outputs, inputs.size), ); } @@ -316,6 +300,18 @@ export class BBNativeRollupProver implements ServerCircuitProver { ); } + public getBlockRootMsgsOnlyRollupProof( + input: BlockRootMsgsOnlyRollupPrivateInputs, + ): Promise> { + return this.createRecursiveProofAndVerify( + input, + 'BlockRootMsgsOnlyRollupArtifact', + NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, + convertBlockRootMsgsOnlyRollupPrivateInputsToWitnessMap, + convertBlockRootMsgsOnlyRollupOutputsFromWitnessMap, + ); + } + public getBlockMergeRollupProof( input: BlockMergeRollupPrivateInputs, ): Promise> { diff --git a/yarn-project/bb-prover/src/test/delay_values.ts b/yarn-project/bb-prover/src/test/delay_values.ts index 023b6c540b5e..a7685e0676b7 100644 --- a/yarn-project/bb-prover/src/test/delay_values.ts +++ b/yarn-project/bb-prover/src/test/delay_values.ts @@ -2,10 +2,10 @@ import { ProvingRequestType } from '@aztec/stdlib/proofs'; export const WITGEN_DELAY_MS: Record = { [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 60, - [ProvingRequestType.PARITY_BASE]: 1_600, - [ProvingRequestType.PARITY_ROOT]: 40, + [ProvingRequestType.INBOX_PARITY]: 1_600, [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 45, [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 18, + [ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP]: 18, [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 27, [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 30, [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 36_000, @@ -25,10 +25,10 @@ export const WITGEN_DELAY_MS: Record = { export const PROOF_DELAY_MS: Record = { [ProvingRequestType.PUBLIC_CHONK_VERIFIER]: 16_300, - [ProvingRequestType.PARITY_BASE]: 15_300, - [ProvingRequestType.PARITY_ROOT]: 18_600, + [ProvingRequestType.INBOX_PARITY]: 15_300, [ProvingRequestType.BLOCK_ROOT_FIRST_ROLLUP]: 17_400, [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: 4_500, + [ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP]: 4_500, [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_FIRST_ROLLUP]: 9_200, [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: 10_200, [ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP]: 37_100, diff --git a/yarn-project/bb-prover/src/test/test_circuit_prover.ts b/yarn-project/bb-prover/src/test/test_circuit_prover.ts index 9ef5ef33cfe2..17e9b22b642d 100644 --- a/yarn-project/bb-prover/src/test/test_circuit_prover.ts +++ b/yarn-project/bb-prover/src/test/test_circuit_prover.ts @@ -15,6 +15,8 @@ import { convertBlockRootEmptyTxFirstRollupPrivateInputsToWitnessMap, convertBlockRootFirstRollupOutputsFromWitnessMap, convertBlockRootFirstRollupPrivateInputsToWitnessMap, + convertBlockRootMsgsOnlyRollupOutputsFromWitnessMap, + convertBlockRootMsgsOnlyRollupPrivateInputsToWitnessMap, convertBlockRootRollupOutputsFromWitnessMap, convertBlockRootRollupPrivateInputsToWitnessMap, convertBlockRootSingleTxFirstRollupOutputsFromWitnessMap, @@ -29,10 +31,8 @@ import { convertCheckpointRootRollupPrivateInputsToWitnessMap, convertCheckpointRootSingleBlockRollupOutputsFromWitnessMap, convertCheckpointRootSingleBlockRollupPrivateInputsToWitnessMap, - convertParityBaseOutputsFromWitnessMap, - convertParityBasePrivateInputsToWitnessMap, - convertParityRootOutputsFromWitnessMap, - convertParityRootPrivateInputsToWitnessMap, + convertInboxParityOutputsFromWitnessMap, + convertInboxParityPrivateInputsToWitnessMap, convertPrivateTxBaseRollupOutputsFromWitnessMap, convertPrivateTxBaseRollupPrivateInputsToWitnessMap, convertPublicTxBaseRollupOutputsFromWitnessMap, @@ -43,6 +43,7 @@ import { convertTxMergeRollupPrivateInputsToWitnessMap, foreignCallHandler, getSimulatedServerCircuitArtifact, + inboxParityArtifactForSize, } from '@aztec/noir-protocol-circuits-types/server'; import { ProtocolCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks'; import { mapProtocolArtifactNameToCircuitName } from '@aztec/noir-protocol-circuits-types/types'; @@ -54,7 +55,7 @@ import { type ServerCircuitProver, makePublicInputsAndRecursiveProof, } from '@aztec/stdlib/interfaces/server'; -import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity'; +import type { InboxParityPrivateInputs, ParityPublicInputs } from '@aztec/stdlib/parity'; import { type Proof, ProvingRequestType, @@ -67,6 +68,7 @@ import { type BlockRollupPublicInputs, type BlockRootEmptyTxFirstRollupPrivateInputs, type BlockRootFirstRollupPrivateInputs, + type BlockRootMsgsOnlyRollupPrivateInputs, type BlockRootRollupPrivateInputs, type BlockRootSingleTxFirstRollupPrivateInputs, type BlockRootSingleTxRollupPrivateInputs, @@ -125,37 +127,17 @@ export class TestCircuitProver implements ServerCircuitProver { * @param inputs - Inputs to the circuit. * @returns The public inputs of the parity circuit. */ - @trackSpan('TestCircuitProver.getBaseParityProof') - public getBaseParityProof( - inputs: ParityBasePrivateInputs, + @trackSpan('TestCircuitProver.getInboxParityProof') + public getInboxParityProof( + inputs: InboxParityPrivateInputs, ): Promise> { - return this.applyDelay(ProvingRequestType.PARITY_BASE, () => + return this.applyDelay(ProvingRequestType.INBOX_PARITY, () => this.simulate( inputs, - 'ParityBaseArtifact', + inboxParityArtifactForSize(inputs.size), RECURSIVE_PROOF_LENGTH, - convertParityBasePrivateInputsToWitnessMap, - convertParityBaseOutputsFromWitnessMap, - ), - ); - } - - /** - * Simulates the root parity circuit from its inputs. - * @param inputs - Inputs to the circuit. - * @returns The public inputs of the parity circuit. - */ - @trackSpan('TestCircuitProver.getRootParityProof') - public getRootParityProof( - inputs: ParityRootPrivateInputs, - ): Promise> { - return this.applyDelay(ProvingRequestType.PARITY_ROOT, () => - this.simulate( - inputs, - 'ParityRootArtifact', - NESTED_RECURSIVE_PROOF_LENGTH, - convertParityRootPrivateInputsToWitnessMap, - convertParityRootOutputsFromWitnessMap, + convertInboxParityPrivateInputsToWitnessMap, + outputs => convertInboxParityOutputsFromWitnessMap(outputs, inputs.size), ), ); } @@ -269,6 +251,21 @@ export class TestCircuitProver implements ServerCircuitProver { ); } + @trackSpan('TestCircuitProver.getBlockRootMsgsOnlyRollupProof') + public getBlockRootMsgsOnlyRollupProof( + input: BlockRootMsgsOnlyRollupPrivateInputs, + ): Promise> { + return this.applyDelay(ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP, () => + this.simulate( + input, + 'BlockRootMsgsOnlyRollupArtifact', + NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, + convertBlockRootMsgsOnlyRollupPrivateInputsToWitnessMap, + convertBlockRootMsgsOnlyRollupOutputsFromWitnessMap, + ), + ); + } + @trackSpan('TestCircuitProver.getBlockRootRollupProof') public getBlockRootRollupProof( input: BlockRootRollupPrivateInputs, diff --git a/yarn-project/end-to-end/src/single-node/proving/prover_restart.parallel.test.ts b/yarn-project/end-to-end/src/single-node/proving/prover_restart.parallel.test.ts index 319ffee9e94f..b8b111fdbc6f 100644 --- a/yarn-project/end-to-end/src/single-node/proving/prover_restart.parallel.test.ts +++ b/yarn-project/end-to-end/src/single-node/proving/prover_restart.parallel.test.ts @@ -33,8 +33,7 @@ const ALL_PROVING_TYPES = Object.values(ProvingRequestType).filter( (t): t is ProvingRequestType => typeof t === 'number', ); -const isParity = (type: ProvingRequestType) => - type === ProvingRequestType.PARITY_BASE || type === ProvingRequestType.PARITY_ROOT; +const isParity = (type: ProvingRequestType) => type === ProvingRequestType.INBOX_PARITY; const isTxBaseRollup = (type: ProvingRequestType) => type === ProvingRequestType.PRIVATE_TX_BASE_ROLLUP || type === ProvingRequestType.PUBLIC_TX_BASE_ROLLUP; diff --git a/yarn-project/ethereum/src/contracts/inbox.ts b/yarn-project/ethereum/src/contracts/inbox.ts index 77bcfd1a1f15..23d7f6ce3df4 100644 --- a/yarn-project/ethereum/src/contracts/inbox.ts +++ b/yarn-project/ethereum/src/contracts/inbox.ts @@ -20,6 +20,10 @@ export type MessageSentArgs = { leaf: Fr; checkpointNumber: CheckpointNumber; rollingHash: Buffer16; + /** Consensus rolling hash (truncated sha256 chain) after this message (AZIP-22 Fast Inbox). Not yet consumed by the node. */ + inboxRollingHash: Fr; + /** Sequence number of the Inbox bucket this message was absorbed into (AZIP-22 Fast Inbox). Not yet consumed by the node. */ + bucketSeq: bigint; }; /** Log type for MessageSent events. */ @@ -100,7 +104,14 @@ export class InboxContract { blockNumber: bigint | null; blockHash: `0x${string}` | null; transactionHash: `0x${string}` | null; - args: { index?: bigint; hash?: `0x${string}`; checkpointNumber?: bigint; rollingHash?: `0x${string}` }; + args: { + index?: bigint; + hash?: `0x${string}`; + checkpointNumber?: bigint; + rollingHash?: `0x${string}`; + inboxRollingHash?: `0x${string}`; + bucketSeq?: bigint; + }; }): MessageSentLog { return { l1BlockNumber: log.blockNumber!, @@ -111,6 +122,8 @@ export class InboxContract { leaf: Fr.fromString(log.args.hash!), checkpointNumber: CheckpointNumber.fromBigInt(log.args.checkpointNumber!), rollingHash: Buffer16.fromString(log.args.rollingHash!), + inboxRollingHash: Fr.fromString(log.args.inboxRollingHash!), + bucketSeq: log.args.bucketSeq!, }, }; } diff --git a/yarn-project/ethereum/src/contracts/rollup.ts b/yarn-project/ethereum/src/contracts/rollup.ts index e08e0085339c..a6726810d088 100644 --- a/yarn-project/ethereum/src/contracts/rollup.ts +++ b/yarn-project/ethereum/src/contracts/rollup.ts @@ -68,6 +68,10 @@ export type EpochProofPublicInputArgs = { previousArchive: `0x${string}`; endArchive: `0x${string}`; outHash: `0x${string}`; + /** Inbox rolling hash before the epoch's first checkpoint's messages. */ + previousInboxRollingHash: `0x${string}`; + /** Inbox rolling hash after the epoch's last checkpoint's messages. */ + endInboxRollingHash: `0x${string}`; proverId: `0x${string}`; }; @@ -76,6 +80,7 @@ export type ViemHeader = { blockHeadersHash: `0x${string}`; blobsHash: `0x${string}`; inHash: `0x${string}`; + inboxRollingHash: `0x${string}`; outHash: `0x${string}`; slotNumber: bigint; timestamp: bigint; diff --git a/yarn-project/ivc-integration/src/base_parity_inputs.test.ts b/yarn-project/ivc-integration/src/base_parity_inputs.test.ts index 523e12618bad..2d5ea50b7092 100644 --- a/yarn-project/ivc-integration/src/base_parity_inputs.test.ts +++ b/yarn-project/ivc-integration/src/base_parity_inputs.test.ts @@ -1,57 +1,90 @@ /** - * Generates base parity circuit inputs (bytecode + witness) for UltraHonk benchmarks. + * Generates parity circuit inputs (bytecode + witness) for UltraHonk benchmarks. * Only runs when BASE_PARITY_BENCH_DIR env var is set by the UltraHonk benchmark input generator. * * Run with: BASE_PARITY_BENCH_DIR=./bench-out yarn workspace @aztec/ivc-integration test src/base_parity_inputs.test.ts + * + * The parity base/root circuits were replaced by the single variable-size InboxParity circuit; this benchmark now + * targets the 256-message rung (`InboxParity256`), matching the old base-parity circuit's size. The + * output files keep their legacy `parity_base.json` / `witness.gz` names because `ci_benchmark_ultrahonk_circuits.sh` + * locates inputs as `${circuit_name}.json` with `circuit_name=parity_base`. */ -import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants'; +import { INBOX_PARITY_SIZE_MEDIUM } from '@aztec/constants'; import { Fr } from '@aztec/foundation/curves/bn254'; import { createLogger } from '@aztec/foundation/log'; import { Noir } from '@aztec/noir-noir_js'; import { ServerCircuitArtifacts } from '@aztec/noir-protocol-circuits-types/server'; import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree'; -import { ParityBasePrivateInputs } from '@aztec/stdlib/parity'; +import { L1ToL2MessageSponge, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging'; +import { InboxParityPrivateInputs } from '@aztec/stdlib/parity'; import { jest } from '@jest/globals'; import * as fs from 'fs/promises'; import * as path from 'path'; -const logger = createLogger('bench:base-parity'); +const logger = createLogger('bench:inbox-parity'); jest.setTimeout(120_000); -describe('Base Parity Benchmark Inputs', () => { - it('generates bytecode and witness files for base parity benchmarking', async () => { +describe('Inbox Parity Benchmark Inputs', () => { + it('generates bytecode and witness files for parity benchmarking', async () => { const outputDir = process.env.BASE_PARITY_BENCH_DIR; if (!outputDir) { - logger.info('Skipping base parity bench input generation (BASE_PARITY_BENCH_DIR not set)'); + logger.info('Skipping parity bench input generation (BASE_PARITY_BENCH_DIR not set)'); return; } - logger.info(`Generating base parity bench inputs to ${outputDir}`); + logger.info(`Generating parity bench inputs to ${outputDir}`); await fs.mkdir(outputDir, { recursive: true }); - // Generate random L1-to-L2 messages - logger.info(`Generating ${NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP} random L1-to-L2 messages...`); - const l1ToL2Messages = new Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(null).map(() => Fr.random()); + // Generate random L1-to-L2 messages that fill the 256-message rung. + logger.info(`Generating ${INBOX_PARITY_SIZE_MEDIUM} random L1-to-L2 messages...`); + const l1ToL2Messages = new Array(INBOX_PARITY_SIZE_MEDIUM).fill(null).map(() => Fr.random()); - // Create base parity inputs for the first slice + // Create InboxParity inputs (picks the 256 rung for 256 messages). const vkTreeRoot = getVKTreeRoot(); - const baseParityInputs = ParityBasePrivateInputs.fromSlice(l1ToL2Messages, 0, vkTreeRoot, Fr.random()); - logger.info('Created base parity inputs'); + const inputs = InboxParityPrivateInputs.fromMessages( + l1ToL2Messages, + Fr.ZERO, + L1ToL2MessageSponge.empty(), + computeInHashFromL1ToL2Messages(l1ToL2Messages), + vkTreeRoot, + Fr.random(), + ); + logger.info('Created inbox parity inputs'); // Convert inputs to Noir format (inline the mapping since it's simple) + const startSponge = inputs.startSponge; const noirInputs = { - msgs: baseParityInputs.msgs.map(m => m.toString()), + msgs: inputs.messages.map(m => m.toString()), + // eslint-disable-next-line camelcase + num_msgs: inputs.numMessages, + // eslint-disable-next-line camelcase + start_rolling_hash: inputs.startRollingHash.toString(), + // eslint-disable-next-line camelcase + start_sponge: { + sponge: { + cache: startSponge.sponge.cache.map(f => f.toString()), + state: startSponge.sponge.state.map(f => f.toString()), + // eslint-disable-next-line camelcase + cache_size: startSponge.sponge.cacheSize, + // eslint-disable-next-line camelcase + squeeze_mode: startSponge.sponge.squeezeMode, + }, + // eslint-disable-next-line camelcase + num_absorbed: startSponge.numAbsorbed, + }, + // eslint-disable-next-line camelcase + in_hash: inputs.inHash.toString(), // eslint-disable-next-line camelcase - vk_tree_root: baseParityInputs.vkTreeRoot.toString(), + vk_tree_root: inputs.vkTreeRoot.toString(), // eslint-disable-next-line camelcase - prover_id: baseParityInputs.proverId.toString(), + prover_id: inputs.proverId.toString(), }; logger.info('Converted inputs to Noir format'); // Get the circuit artifact - const artifact = ServerCircuitArtifacts.ParityBaseArtifact; + const artifact = ServerCircuitArtifacts.InboxParity256Artifact; // Execute the circuit with Noir to generate witness logger.info('Executing circuit with Noir to generate witness...'); @@ -59,7 +92,7 @@ describe('Base Parity Benchmark Inputs', () => { const { witness } = await program.execute({ inputs: noirInputs }); logger.info('Witness generated'); - // Save bytecode as JSON (bb expects the full JSON artifact) + // Save bytecode as JSON (bb expects the full JSON artifact). Filename is the harness's legacy contract. const bytecodeOutputPath = path.join(outputDir, 'parity_base.json'); await fs.writeFile(bytecodeOutputPath, JSON.stringify(artifact)); logger.info(`Wrote bytecode to ${bytecodeOutputPath}`); @@ -69,7 +102,7 @@ describe('Base Parity Benchmark Inputs', () => { await fs.writeFile(witnessOutputPath, witness); logger.info(`Wrote witness to ${witnessOutputPath}`); - logger.info('Base parity bench inputs generated successfully'); + logger.info('Inbox parity bench inputs generated successfully'); logger.info(`Output directory: ${outputDir}`); logger.info('Files:'); logger.info(` - ${bytecodeOutputPath} (circuit bytecode)`); diff --git a/yarn-project/ivc-integration/src/bb_js_debug.test.ts b/yarn-project/ivc-integration/src/bb_js_debug.test.ts index b7d6c2c4ea1f..f478e61dd182 100644 --- a/yarn-project/ivc-integration/src/bb_js_debug.test.ts +++ b/yarn-project/ivc-integration/src/bb_js_debug.test.ts @@ -6,13 +6,14 @@ */ import { BBJsInstance, type BBJsProofResult } from '@aztec/bb-prover'; import { DebugBBJsInstance } from '@aztec/bb-prover/debug'; -import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants'; +import { INBOX_PARITY_SIZE_MEDIUM } from '@aztec/constants'; import { Fr } from '@aztec/foundation/curves/bn254'; import { createLogger } from '@aztec/foundation/log'; import { Noir } from '@aztec/noir-noir_js'; import { ServerCircuitArtifacts } from '@aztec/noir-protocol-circuits-types/server'; import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree'; -import { ParityBasePrivateInputs } from '@aztec/stdlib/parity'; +import { L1ToL2MessageSponge, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging'; +import { InboxParityPrivateInputs } from '@aztec/stdlib/parity'; import { jest } from '@jest/globals'; import * as proc from 'child_process'; @@ -54,20 +55,47 @@ describe('BB.js Debug Wrapper', () => { // Create a temporary debug output directory debugDir = await fs.mkdtemp(path.join(process.env.BB_WORKING_DIRECTORY || '/tmp', 'bb-debug-test-')); - // Generate base parity inputs (same approach as base_parity_inputs.test.ts) - const l1ToL2Messages = new Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(null).map(() => Fr.random()); + // Generate inbox parity inputs (same approach as base_parity_inputs.test.ts) + const l1ToL2Messages = new Array(INBOX_PARITY_SIZE_MEDIUM).fill(null).map(() => Fr.random()); const vkTreeRoot = getVKTreeRoot(); - const baseParityInputs = ParityBasePrivateInputs.fromSlice(l1ToL2Messages, 0, vkTreeRoot, Fr.random()); + const inboxParityInputs = InboxParityPrivateInputs.fromMessages( + l1ToL2Messages, + Fr.ZERO, + L1ToL2MessageSponge.empty(), + computeInHashFromL1ToL2Messages(l1ToL2Messages), + vkTreeRoot, + Fr.random(), + ); + const startSponge = inboxParityInputs.startSponge; const noirInputs = { - msgs: baseParityInputs.msgs.map(m => m.toString()), + msgs: inboxParityInputs.messages.map(m => m.toString()), + // eslint-disable-next-line camelcase + num_msgs: inboxParityInputs.numMessages, + // eslint-disable-next-line camelcase + start_rolling_hash: inboxParityInputs.startRollingHash.toString(), + // eslint-disable-next-line camelcase + start_sponge: { + sponge: { + cache: startSponge.sponge.cache.map(f => f.toString()), + state: startSponge.sponge.state.map(f => f.toString()), + // eslint-disable-next-line camelcase + cache_size: startSponge.sponge.cacheSize, + // eslint-disable-next-line camelcase + squeeze_mode: startSponge.sponge.squeezeMode, + }, + // eslint-disable-next-line camelcase + num_absorbed: startSponge.numAbsorbed, + }, + // eslint-disable-next-line camelcase + in_hash: inboxParityInputs.inHash.toString(), // eslint-disable-next-line camelcase - vk_tree_root: baseParityInputs.vkTreeRoot.toString(), + vk_tree_root: inboxParityInputs.vkTreeRoot.toString(), // eslint-disable-next-line camelcase - prover_id: baseParityInputs.proverId.toString(), + prover_id: inboxParityInputs.proverId.toString(), }; - const artifact = ServerCircuitArtifacts.ParityBaseArtifact; + const artifact = ServerCircuitArtifacts.InboxParity256Artifact; // Execute circuit with Noir JS to generate witness logger.info('Generating witness via Noir JS...'); @@ -85,7 +113,7 @@ describe('BB.js Debug Wrapper', () => { const debug = new DebugBBJsInstance(raw, debugDir, BB_PATH, logger); try { - bbJsResult = await debug.generateProof('ParityBase', bytecode, vkBytes, witness, 'ultra_honk'); + bbJsResult = await debug.generateProof('InboxParity256', bytecode, vkBytes, witness, 'ultra_honk'); logger.info( `bb.js proof generated: ${bbJsResult.proofFields.length} proof fields, ${bbJsResult.publicInputFields.length} public input fields`, ); @@ -102,12 +130,12 @@ describe('BB.js Debug Wrapper', () => { }); it('writes correct debug files and command.sh', async () => { - const opDir = path.join(debugDir, 'ParityBase-001'); + const opDir = path.join(debugDir, 'InboxParity256-001'); // Check all expected files exist const files = await fs.readdir(opDir); - expect(files).toContain('ParityBase-bytecode.gz'); - expect(files).toContain('ParityBase-vk'); + expect(files).toContain('InboxParity256-bytecode.gz'); + expect(files).toContain('InboxParity256-vk'); expect(files).toContain('partial-witness.gz'); expect(files).toContain('proof'); expect(files).toContain('public_inputs'); @@ -126,15 +154,15 @@ describe('BB.js Debug Wrapper', () => { }); it('CLI bb prove reproduces the same proof as bb.js', async () => { - const opDir = path.join(debugDir, 'ParityBase-001'); + const opDir = path.join(debugDir, 'InboxParity256-001'); // Create a separate output directory for the CLI proof const cliOutputDir = path.join(debugDir, 'cli-prove-output'); await fs.mkdir(cliOutputDir, { recursive: true }); // Run the bb prove command using the same input files - const bytecodePath = path.join(opDir, 'ParityBase-bytecode.gz'); - const vkPath = path.join(opDir, 'ParityBase-vk'); + const bytecodePath = path.join(opDir, 'InboxParity256-bytecode.gz'); + const vkPath = path.join(opDir, 'InboxParity256-vk'); const witnessPath = path.join(opDir, 'partial-witness.gz'); const logFn = (msg: string) => logger.verbose(`bb-cli - ${msg}`); @@ -175,7 +203,7 @@ describe('BB.js Debug Wrapper', () => { }); it('CLI bb verify succeeds with debug output files', async () => { - const opDir = path.join(debugDir, 'ParityBase-001'); + const opDir = path.join(debugDir, 'InboxParity256-001'); // We need the VK produced by the prover (not the input VK). // The prove command writes a VK only with --write_vk. Instead, we write_vk separately @@ -185,7 +213,7 @@ describe('BB.js Debug Wrapper', () => { const vkDir = path.join(debugDir, 'cli-vk-output'); await fs.mkdir(vkDir, { recursive: true }); - const bytecodePath = path.join(opDir, 'ParityBase-bytecode.gz'); + const bytecodePath = path.join(opDir, 'InboxParity256-bytecode.gz'); // Generate VK via CLI const logFn = (msg: string) => logger.verbose(`bb-cli - ${msg}`); diff --git a/yarn-project/noir-protocol-circuits-types/src/artifacts/server.ts b/yarn-project/noir-protocol-circuits-types/src/artifacts/server.ts index c2c2fea39c78..b0e00e56b414 100644 --- a/yarn-project/noir-protocol-circuits-types/src/artifacts/server.ts +++ b/yarn-project/noir-protocol-circuits-types/src/artifacts/server.ts @@ -1,8 +1,9 @@ import type { NoirCompiledCircuit, NoirCompiledCircuitWithName } from '@aztec/stdlib/noir'; import PublicChonkVerifierJson from '../../artifacts/chonk_verifier_public.json' with { type: 'json' }; -import ParityBaseJson from '../../artifacts/parity_base.json' with { type: 'json' }; -import ParityRootJson from '../../artifacts/parity_root.json' with { type: 'json' }; +import InboxParity64Json from '../../artifacts/inbox_parity_64.json' with { type: 'json' }; +import InboxParity256Json from '../../artifacts/inbox_parity_256.json' with { type: 'json' }; +import InboxParity1024Json from '../../artifacts/inbox_parity_1024.json' with { type: 'json' }; import BlockMergeRollupJson from '../../artifacts/rollup_block_merge.json' with { type: 'json' }; import BlockRootRollupJson from '../../artifacts/rollup_block_root.json' with { type: 'json' }; import BlockRootFirstRollupJson from '../../artifacts/rollup_block_root_first.json' with { type: 'json' }; @@ -10,6 +11,7 @@ import BlockRootEmptyTxFirstRollupJson from '../../artifacts/rollup_block_root_f import BlockRootFirstRollupSimulatedJson from '../../artifacts/rollup_block_root_first_simulated.json' with { type: 'json' }; import BlockRootSingleTxFirstRollupJson from '../../artifacts/rollup_block_root_first_single_tx.json' with { type: 'json' }; import BlockRootSingleTxFirstRollupSimulatedJson from '../../artifacts/rollup_block_root_first_single_tx_simulated.json' with { type: 'json' }; +import BlockRootMsgsOnlyRollupJson from '../../artifacts/rollup_block_root_msgs_only.json' with { type: 'json' }; import BlockRootRollupSimulatedJson from '../../artifacts/rollup_block_root_simulated.json' with { type: 'json' }; import BlockRootSingleTxRollupJson from '../../artifacts/rollup_block_root_single_tx.json' with { type: 'json' }; import BlockRootSingleTxRollupSimulatedJson from '../../artifacts/rollup_block_root_single_tx_simulated.json' with { type: 'json' }; @@ -28,8 +30,9 @@ import TxMergeRollupJson from '../../artifacts/rollup_tx_merge.json' with { type import type { ServerProtocolArtifact } from './types.js'; export const ServerCircuitArtifacts: Record = { - ParityBaseArtifact: ParityBaseJson as NoirCompiledCircuit, - ParityRootArtifact: ParityRootJson as NoirCompiledCircuit, + InboxParity64Artifact: InboxParity64Json as NoirCompiledCircuit, + InboxParity256Artifact: InboxParity256Json as NoirCompiledCircuit, + InboxParity1024Artifact: InboxParity1024Json as NoirCompiledCircuit, PublicChonkVerifier: PublicChonkVerifierJson as NoirCompiledCircuit, PrivateTxBaseRollupArtifact: PrivateTxBaseRollupJson as NoirCompiledCircuit, PublicTxBaseRollupArtifact: PublicTxBaseRollupJson as NoirCompiledCircuit, @@ -39,6 +42,7 @@ export const ServerCircuitArtifacts: Record = { - ParityBaseArtifact: ParityBaseJson as NoirCompiledCircuit, - ParityRootArtifact: ParityRootJson as NoirCompiledCircuit, + // No separate simulated build for the inbox parity ladder: they verify no child proofs, so the constrained + // artifacts are used for simulation too. + InboxParity64Artifact: InboxParity64Json as NoirCompiledCircuit, + InboxParity256Artifact: InboxParity256Json as NoirCompiledCircuit, + InboxParity1024Artifact: InboxParity1024Json as NoirCompiledCircuit, PublicChonkVerifier: PublicChonkVerifierJson as NoirCompiledCircuit, PrivateTxBaseRollupArtifact: PrivateTxBaseRollupSimulatedJson as NoirCompiledCircuit, PublicTxBaseRollupArtifact: PublicTxBaseRollupSimulatedJson as NoirCompiledCircuit, @@ -59,6 +66,9 @@ export const SimulatedServerCircuitArtifacts: Record = { - ParityBaseArtifact: abiToVKData(ParityBase), - ParityRootArtifact: abiToVKData(ParityRoot), + InboxParity64Artifact: abiToVKData(InboxParity64), + InboxParity256Artifact: abiToVKData(InboxParity256), + InboxParity1024Artifact: abiToVKData(InboxParity1024), PublicChonkVerifier: abiToVKData(PublicChonkVerifier), PrivateTxBaseRollupArtifact: abiToVKData(PrivateTxBaseRollup), PublicTxBaseRollupArtifact: abiToVKData(PublicTxBaseRollup), @@ -68,6 +73,7 @@ export const ServerCircuitVks: Record = { HidingKernelToRollup: HIDING_KERNEL_TO_ROLLUP_VK_INDEX, HidingKernelToPublic: HIDING_KERNEL_TO_PUBLIC_VK_INDEX, PublicChonkVerifier: PUBLIC_CHONK_VERIFIER_VK_INDEX, - ParityBaseArtifact: PARITY_BASE_VK_INDEX, - ParityRootArtifact: PARITY_ROOT_VK_INDEX, + InboxParity64Artifact: INBOX_PARITY_64_VK_INDEX, + InboxParity256Artifact: INBOX_PARITY_256_VK_INDEX, + InboxParity1024Artifact: INBOX_PARITY_1024_VK_INDEX, PrivateTxBaseRollupArtifact: PRIVATE_TX_BASE_ROLLUP_VK_INDEX, PublicTxBaseRollupArtifact: PUBLIC_TX_BASE_ROLLUP_VK_INDEX, TxMergeRollupArtifact: TX_MERGE_ROLLUP_VK_INDEX, @@ -102,6 +109,7 @@ export const ProtocolCircuitVkIndexes: Record = { BlockRootEmptyTxFirstRollupArtifact: BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP_VK_INDEX, BlockRootRollupArtifact: BLOCK_ROOT_ROLLUP_VK_INDEX, BlockRootSingleTxRollupArtifact: BLOCK_ROOT_SINGLE_TX_ROLLUP_VK_INDEX, + BlockRootMsgsOnlyRollupArtifact: BLOCK_ROOT_MSGS_ONLY_ROLLUP_VK_INDEX, BlockMergeRollupArtifact: BLOCK_MERGE_ROLLUP_VK_INDEX, CheckpointRootRollupArtifact: CHECKPOINT_ROOT_ROLLUP_VK_INDEX, CheckpointRootSingleBlockRollupArtifact: CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP_VK_INDEX, diff --git a/yarn-project/noir-protocol-circuits-types/src/conversion/server.ts b/yarn-project/noir-protocol-circuits-types/src/conversion/server.ts index af399f11fbfd..b9670f1900bc 100644 --- a/yarn-project/noir-protocol-circuits-types/src/conversion/server.ts +++ b/yarn-project/noir-protocol-circuits-types/src/conversion/server.ts @@ -12,6 +12,7 @@ import { CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH, MAX_CHECKPOINTS_PER_EPOCH, + MAX_L1_TO_L2_MSGS_PER_BLOCK, type NULLIFIER_TREE_HEIGHT, ULTRA_VK_LENGTH_IN_FIELDS, } from '@aztec/constants'; @@ -32,7 +33,8 @@ import { PrivateToPublicKernelCircuitPublicInputs, } from '@aztec/stdlib/kernel'; import type { FlatPublicLogs } from '@aztec/stdlib/logs'; -import { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity'; +import { L1ToL2MessageBundle, L1ToL2MessageSponge } from '@aztec/stdlib/messaging'; +import { InboxParityPrivateInputs, ParityPublicInputs } from '@aztec/stdlib/parity'; import type { ProofData, ProofDataForFixedVk, RecursiveProof } from '@aztec/stdlib/proofs'; import { BlockConstantData, @@ -40,6 +42,7 @@ import { BlockRollupPublicInputs, BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, + BlockRootMsgsOnlyRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, @@ -76,6 +79,7 @@ import type { BlockRollupPublicInputs as BlockRollupPublicInputsNoir, BlockRootEmptyTxFirstRollupPrivateInputs as BlockRootEmptyTxFirstRollupPrivateInputsNoir, BlockRootFirstRollupPrivateInputs as BlockRootFirstRollupPrivateInputsNoir, + BlockRootMsgsOnlyRollupPrivateInputs as BlockRootMsgsOnlyRollupPrivateInputsNoir, BlockRootRollupPrivateInputs as BlockRootRollupPrivateInputsNoir, BlockRootSingleTxFirstRollupPrivateInputs as BlockRootSingleTxFirstRollupPrivateInputsNoir, BlockRootSingleTxRollupPrivateInputs as BlockRootSingleTxRollupPrivateInputsNoir, @@ -90,10 +94,9 @@ import type { FinalBlobAccumulator as FinalBlobAccumulatorNoir, FinalBlobBatchingChallenges as FinalBlobBatchingChallengesNoir, FixedLengthArray, + L1ToL2MessageSponge as L1ToL2MessageSpongeNoir, Field as NoirField, - ParityBasePrivateInputs as ParityBasePrivateInputsNoir, ParityPublicInputs as ParityPublicInputsNoir, - ParityRootPrivateInputs as ParityRootPrivateInputsNoir, Poseidon2Sponge as Poseidon2SpongeNoir, PrivateToAvmAccumulatedDataArrayLengths as PrivateToAvmAccumulatedDataArrayLengthsNoir, PrivateToAvmAccumulatedData as PrivateToAvmAccumulatedDataNoir, @@ -265,6 +268,17 @@ function mapSpongeBlobFromNoir(spongeBlob: SpongeBlobNoir): SpongeBlob { ); } +function mapL1ToL2MessageSpongeToNoir(sponge: L1ToL2MessageSponge): L1ToL2MessageSpongeNoir { + return { + sponge: mapPoseidon2SpongeToNoir(sponge.sponge), + num_absorbed: mapNumberToNoir(sponge.numAbsorbed), + }; +} + +function mapL1ToL2MessageSpongeFromNoir(sponge: L1ToL2MessageSpongeNoir): L1ToL2MessageSponge { + return new L1ToL2MessageSponge(mapPoseidon2SpongeFromNoir(sponge.sponge), mapNumberFromNoir(sponge.num_absorbed)); +} + /** * Maps blob challenges to noir. * @param challenges - The stdlib challenges. @@ -467,8 +481,12 @@ export function mapAvmProofDataToNoir( function mapParityPublicInputsToNoir(parityPublicInputs: ParityPublicInputs): ParityPublicInputsNoir { return { - sha_root: mapFieldToNoir(parityPublicInputs.shaRoot), - converted_root: mapFieldToNoir(parityPublicInputs.convertedRoot), + in_hash: mapFieldToNoir(parityPublicInputs.inHash), + start_rolling_hash: mapFieldToNoir(parityPublicInputs.startRollingHash), + end_rolling_hash: mapFieldToNoir(parityPublicInputs.endRollingHash), + start_sponge: mapL1ToL2MessageSpongeToNoir(parityPublicInputs.startSponge), + end_sponge: mapL1ToL2MessageSpongeToNoir(parityPublicInputs.endSponge), + num_msgs: mapNumberToNoir(parityPublicInputs.numMsgs), vk_tree_root: mapFieldToNoir(parityPublicInputs.vkTreeRoot), prover_id: mapFieldToNoir(parityPublicInputs.proverId), }; @@ -486,6 +504,8 @@ export function mapRootRollupPublicInputsFromNoir( mapFieldFromNoir(rootRollupPublicInputs.previous_archive_root), mapFieldFromNoir(rootRollupPublicInputs.new_archive_root), mapFieldFromNoir(rootRollupPublicInputs.out_hash), + mapFieldFromNoir(rootRollupPublicInputs.previous_inbox_rolling_hash), + mapFieldFromNoir(rootRollupPublicInputs.end_inbox_rolling_hash), mapTupleFromNoir(rootRollupPublicInputs.checkpoint_header_hashes, MAX_CHECKPOINTS_PER_EPOCH, mapFieldFromNoir), mapTupleFromNoir(rootRollupPublicInputs.fees, MAX_CHECKPOINTS_PER_EPOCH, mapFeeRecipientFromNoir), mapEpochConstantDataFromNoir(rootRollupPublicInputs.constants), @@ -500,8 +520,12 @@ export function mapRootRollupPublicInputsFromNoir( */ export function mapParityPublicInputsFromNoir(parityPublicInputs: ParityPublicInputsNoir): ParityPublicInputs { return new ParityPublicInputs( - mapFieldFromNoir(parityPublicInputs.sha_root), - mapFieldFromNoir(parityPublicInputs.converted_root), + mapFieldFromNoir(parityPublicInputs.in_hash), + mapFieldFromNoir(parityPublicInputs.start_rolling_hash), + mapFieldFromNoir(parityPublicInputs.end_rolling_hash), + mapL1ToL2MessageSpongeFromNoir(parityPublicInputs.start_sponge), + mapL1ToL2MessageSpongeFromNoir(parityPublicInputs.end_sponge), + mapNumberFromNoir(parityPublicInputs.num_msgs), mapFieldFromNoir(parityPublicInputs.vk_tree_root), mapFieldFromNoir(parityPublicInputs.prover_id), ); @@ -608,7 +632,9 @@ export function mapBlockRollupPublicInputsFromNoir(inputs: BlockRollupPublicInpu mapSpongeBlobFromNoir(inputs.end_sponge_blob), mapU64FromNoir(inputs.timestamp), mapFieldFromNoir(inputs.block_headers_hash), - mapFieldFromNoir(inputs.in_hash), + inputs.is_first_block, + mapL1ToL2MessageSpongeFromNoir(inputs.start_msg_sponge), + mapL1ToL2MessageSpongeFromNoir(inputs.end_msg_sponge), mapFieldFromNoir(inputs.out_hash), mapFieldFromNoir(inputs.accumulated_fees), mapFieldFromNoir(inputs.accumulated_mana_used), @@ -626,7 +652,9 @@ export function mapBlockRollupPublicInputsToNoir(inputs: BlockRollupPublicInputs end_sponge_blob: mapSpongeBlobToNoir(inputs.endSpongeBlob), timestamp: mapU64ToNoir(inputs.timestamp), block_headers_hash: mapFieldToNoir(inputs.blockHeadersHash), - in_hash: mapFieldToNoir(inputs.inHash), + is_first_block: inputs.isFirstBlock, + start_msg_sponge: mapL1ToL2MessageSpongeToNoir(inputs.startMsgSponge), + end_msg_sponge: mapL1ToL2MessageSpongeToNoir(inputs.endMsgSponge), out_hash: mapFieldToNoir(inputs.outHash), accumulated_fees: mapFieldToNoir(inputs.accumulatedFees), accumulated_mana_used: mapFieldToNoir(inputs.accumulatedManaUsed), @@ -640,6 +668,8 @@ export function mapCheckpointRollupPublicInputsFromNoir(inputs: CheckpointRollup mapAppendOnlyTreeSnapshotFromNoir(inputs.new_archive), mapAppendOnlyTreeSnapshotFromNoir(inputs.previous_out_hash), mapAppendOnlyTreeSnapshotFromNoir(inputs.new_out_hash), + mapFieldFromNoir(inputs.start_inbox_rolling_hash), + mapFieldFromNoir(inputs.end_inbox_rolling_hash), mapTupleFromNoir(inputs.checkpoint_header_hashes, MAX_CHECKPOINTS_PER_EPOCH, mapFieldFromNoir), mapTupleFromNoir(inputs.fees, MAX_CHECKPOINTS_PER_EPOCH, mapFeeRecipientFromNoir), mapBlobAccumulatorFromNoir(inputs.start_blob_accumulator), @@ -657,6 +687,8 @@ export function mapCheckpointRollupPublicInputsToNoir( new_archive: mapAppendOnlyTreeSnapshotToNoir(inputs.newArchive), previous_out_hash: mapAppendOnlyTreeSnapshotToNoir(inputs.previousOutHash), new_out_hash: mapAppendOnlyTreeSnapshotToNoir(inputs.newOutHash), + start_inbox_rolling_hash: mapFieldToNoir(inputs.startInboxRollingHash), + end_inbox_rolling_hash: mapFieldToNoir(inputs.endInboxRollingHash), checkpoint_header_hashes: mapTuple(inputs.checkpointHeaderHashes, mapFieldToNoir), fees: mapTuple(inputs.fees, mapFeeRecipientToNoir), start_blob_accumulator: mapBlobAccumulatorToNoir(inputs.startBlobAccumulator), @@ -699,22 +731,20 @@ function mapTreeSnapshotDiffHintsToNoir(hints: TreeSnapshotDiffHints): TreeSnaps }; } -export function mapParityBasePrivateInputsToNoir(inputs: ParityBasePrivateInputs): ParityBasePrivateInputsNoir { +// Maps the size-generic InboxParity inputs to the Noir struct. The `messages` array length already equals the chosen +// ladder size, so the same object satisfies whichever size-specific artifact ABI is selected by `inputs.size`. +export function mapInboxParityPrivateInputsToNoir(inputs: InboxParityPrivateInputs) { return { - msgs: mapTuple(inputs.msgs, mapFieldToNoir), + msgs: mapFieldArrayToNoir(inputs.messages), + num_msgs: mapNumberToNoir(inputs.numMessages), + start_rolling_hash: mapFieldToNoir(inputs.startRollingHash), + start_sponge: mapL1ToL2MessageSpongeToNoir(inputs.startSponge), + in_hash: mapFieldToNoir(inputs.inHash), vk_tree_root: mapFieldToNoir(inputs.vkTreeRoot), prover_id: mapFieldToNoir(inputs.proverId), }; } -export function mapParityRootPrivateInputsToNoir(inputs: ParityRootPrivateInputs): ParityRootPrivateInputsNoir { - return { - children: mapTuple(inputs.children, c => - mapProofDataToNoir(c, mapParityPublicInputsToNoir, ULTRA_VK_LENGTH_IN_FIELDS), - ), - }; -} - export function mapPublicChonkVerifierPrivateInputsToNoir( inputs: PublicChonkVerifierPrivateInputs, ): PublicChonkVerifierPrivateInputsNoir { @@ -800,20 +830,27 @@ export function mapRevertCodeToNoir(revertCode: RevertCode): NoirField { return mapFieldToNoir(revertCode.toField()); } +function mapL1ToL2MessageBundleToNoir(bundle: L1ToL2MessageBundle) { + return { + // `messages` is a plain `Fr[]` (padded to the cap) rather than a fixed tuple, so pass the length explicitly to + // get the fixed-length `FixedLengthArray` the generated `L1ToL2MessageBundle.messages` type requires. + messages: mapFieldArrayToNoir(bundle.messages, MAX_L1_TO_L2_MSGS_PER_BLOCK), + num_msgs: mapNumberToNoir(bundle.numMsgs), + num_real_msgs: mapNumberToNoir(bundle.numRealMsgs), + }; +} + export function mapBlockRootFirstRollupPrivateInputsToNoir( inputs: BlockRootFirstRollupPrivateInputs, ): BlockRootFirstRollupPrivateInputsNoir { return { - parity_root: mapProofDataToNoir(inputs.l1ToL2Roots, mapParityPublicInputsToNoir), previous_rollups: [ mapProofDataToNoir(inputs.previousRollups[0], mapTxRollupPublicInputsToNoir), mapProofDataToNoir(inputs.previousRollups[1], mapTxRollupPublicInputsToNoir), ], + message_bundle: mapL1ToL2MessageBundleToNoir(inputs.messageBundle), previous_l1_to_l2: mapAppendOnlyTreeSnapshotToNoir(inputs.previousL1ToL2), - new_l1_to_l2_message_subtree_root_sibling_path: mapTuple( - inputs.newL1ToL2MessageSubtreeRootSiblingPath, - mapFieldToNoir, - ), + l1_to_l2_message_frontier_hint: mapTuple(inputs.l1ToL2MessageFrontierHint, mapFieldToNoir), new_archive_sibling_path: mapTuple(inputs.newArchiveSiblingPath, mapFieldToNoir), }; } @@ -822,13 +859,10 @@ export function mapBlockRootSingleTxFirstRollupPrivateInputsToNoir( inputs: BlockRootSingleTxFirstRollupPrivateInputs, ): BlockRootSingleTxFirstRollupPrivateInputsNoir { return { - parity_root: mapProofDataToNoir(inputs.l1ToL2Roots, mapParityPublicInputsToNoir), previous_rollup: mapProofDataToNoir(inputs.previousRollup, mapTxRollupPublicInputsToNoir), + message_bundle: mapL1ToL2MessageBundleToNoir(inputs.messageBundle), previous_l1_to_l2: mapAppendOnlyTreeSnapshotToNoir(inputs.previousL1ToL2), - new_l1_to_l2_message_subtree_root_sibling_path: mapTuple( - inputs.newL1ToL2MessageSubtreeRootSiblingPath, - mapFieldToNoir, - ), + l1_to_l2_message_frontier_hint: mapTuple(inputs.l1ToL2MessageFrontierHint, mapFieldToNoir), new_archive_sibling_path: mapTuple(inputs.newArchiveSiblingPath, mapFieldToNoir), }; } @@ -837,15 +871,28 @@ export function mapBlockRootEmptyTxFirstRollupPrivateInputsToNoir( inputs: BlockRootEmptyTxFirstRollupPrivateInputs, ): BlockRootEmptyTxFirstRollupPrivateInputsNoir { return { - parity_root: mapProofDataToNoir(inputs.l1ToL2Roots, mapParityPublicInputsToNoir), previous_archive: mapAppendOnlyTreeSnapshotToNoir(inputs.previousArchive), previous_state: mapStateReferenceToNoir(inputs.previousState), constants: mapCheckpointConstantDataToNoir(inputs.constants), timestamp: mapU64ToNoir(inputs.timestamp), - new_l1_to_l2_message_subtree_root_sibling_path: mapTuple( - inputs.newL1ToL2MessageSubtreeRootSiblingPath, - mapFieldToNoir, - ), + message_bundle: mapL1ToL2MessageBundleToNoir(inputs.messageBundle), + l1_to_l2_message_frontier_hint: mapTuple(inputs.l1ToL2MessageFrontierHint, mapFieldToNoir), + new_archive_sibling_path: mapTuple(inputs.newArchiveSiblingPath, mapFieldToNoir), + }; +} + +export function mapBlockRootMsgsOnlyRollupPrivateInputsToNoir( + inputs: BlockRootMsgsOnlyRollupPrivateInputs, +): BlockRootMsgsOnlyRollupPrivateInputsNoir { + return { + previous_archive: mapAppendOnlyTreeSnapshotToNoir(inputs.previousArchive), + previous_state: mapStateReferenceToNoir(inputs.previousState), + constants: mapCheckpointConstantDataToNoir(inputs.constants), + timestamp: mapU64ToNoir(inputs.timestamp), + start_sponge_blob: mapSpongeBlobToNoir(inputs.startSpongeBlob), + start_msg_sponge: mapL1ToL2MessageSpongeToNoir(inputs.startMsgSponge), + message_bundle: mapL1ToL2MessageBundleToNoir(inputs.messageBundle), + l1_to_l2_message_frontier_hint: mapTuple(inputs.l1ToL2MessageFrontierHint, mapFieldToNoir), new_archive_sibling_path: mapTuple(inputs.newArchiveSiblingPath, mapFieldToNoir), }; } @@ -858,6 +905,10 @@ export function mapBlockRootRollupPrivateInputsToNoir( mapProofDataToNoir(inputs.previousRollups[0], mapTxRollupPublicInputsToNoir), mapProofDataToNoir(inputs.previousRollups[1], mapTxRollupPublicInputsToNoir), ], + message_bundle: mapL1ToL2MessageBundleToNoir(inputs.messageBundle), + previous_l1_to_l2: mapAppendOnlyTreeSnapshotToNoir(inputs.previousL1ToL2), + start_msg_sponge: mapL1ToL2MessageSpongeToNoir(inputs.startMsgSponge), + l1_to_l2_message_frontier_hint: mapTuple(inputs.l1ToL2MessageFrontierHint, mapFieldToNoir), new_archive_sibling_path: mapTuple(inputs.newArchiveSiblingPath, mapFieldToNoir), }; } @@ -867,6 +918,10 @@ export function mapBlockRootSingleTxRollupPrivateInputsToNoir( ): BlockRootSingleTxRollupPrivateInputsNoir { return { previous_rollup: mapProofDataToNoir(inputs.previousRollup, mapTxRollupPublicInputsToNoir), + message_bundle: mapL1ToL2MessageBundleToNoir(inputs.messageBundle), + previous_l1_to_l2: mapAppendOnlyTreeSnapshotToNoir(inputs.previousL1ToL2), + start_msg_sponge: mapL1ToL2MessageSpongeToNoir(inputs.startMsgSponge), + l1_to_l2_message_frontier_hint: mapTuple(inputs.l1ToL2MessageFrontierHint, mapFieldToNoir), new_archive_sibling_path: mapTuple(inputs.newArchiveSiblingPath, mapFieldToNoir), }; } @@ -904,6 +959,7 @@ export function mapCheckpointRootRollupPrivateInputsToNoir( mapProofDataToNoir(inputs.previousRollups[0], mapBlockRollupPublicInputsToNoir), mapProofDataToNoir(inputs.previousRollups[1], mapBlockRollupPublicInputsToNoir), ], + inbox_parity: mapProofDataToNoir(inputs.inboxParity, mapParityPublicInputsToNoir, ULTRA_VK_LENGTH_IN_FIELDS), hints: mapCheckpointRootRollupHintsToNoir(inputs.hints), }; } @@ -913,6 +969,7 @@ export function mapCheckpointRootSingleBlockRollupPrivateInputsToNoir( ): CheckpointRootSingleBlockRollupPrivateInputsNoir { return { previous_rollup: mapProofDataToNoir(inputs.previousRollup, mapBlockRollupPublicInputsToNoir), + inbox_parity: mapProofDataToNoir(inputs.inboxParity, mapParityPublicInputsToNoir, ULTRA_VK_LENGTH_IN_FIELDS), hints: mapCheckpointRootRollupHintsToNoir(inputs.hints), }; } diff --git a/yarn-project/noir-protocol-circuits-types/src/execution/server.ts b/yarn-project/noir-protocol-circuits-types/src/execution/server.ts index a2719392b148..b30e84876ebf 100644 --- a/yarn-project/noir-protocol-circuits-types/src/execution/server.ts +++ b/yarn-project/noir-protocol-circuits-types/src/execution/server.ts @@ -1,12 +1,14 @@ +import { INBOX_PARITY_SIZE_LARGE, INBOX_PARITY_SIZE_MEDIUM, INBOX_PARITY_SIZE_SMALL } from '@aztec/constants'; import { pushTestData } from '@aztec/foundation/testing'; import type { WitnessMap } from '@aztec/noir-acvm_js'; import { abiDecode, abiEncode } from '@aztec/noir-noirc_abi'; -import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity'; +import type { InboxParityPrivateInputs, ParityPublicInputs } from '@aztec/stdlib/parity'; import type { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, + BlockRootMsgsOnlyRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, @@ -32,6 +34,7 @@ import { mapBlockRollupPublicInputsFromNoir, mapBlockRootEmptyTxFirstRollupPrivateInputsToNoir, mapBlockRootFirstRollupPrivateInputsToNoir, + mapBlockRootMsgsOnlyRollupPrivateInputsToNoir, mapBlockRootRollupPrivateInputsToNoir, mapBlockRootSingleTxFirstRollupPrivateInputsToNoir, mapBlockRootSingleTxRollupPrivateInputsToNoir, @@ -39,9 +42,8 @@ import { mapCheckpointRollupPublicInputsFromNoir, mapCheckpointRootRollupPrivateInputsToNoir, mapCheckpointRootSingleBlockRollupPrivateInputsToNoir, - mapParityBasePrivateInputsToNoir, + mapInboxParityPrivateInputsToNoir, mapParityPublicInputsFromNoir, - mapParityRootPrivateInputsToNoir, mapPrivateTxBaseRollupPrivateInputsToNoir, mapPublicChonkVerifierPrivateInputsToNoir, mapPublicChonkVerifierPublicInputsFromNoir, @@ -53,12 +55,12 @@ import { } from '../conversion/server.js'; import type { ChonkVerifierPublicReturnType, - ParityBaseReturnType, - ParityRootReturnType, + InboxParity64ReturnType, RollupBlockMergeReturnType, RollupBlockRootFirstEmptyTxReturnType, RollupBlockRootFirstReturnType, RollupBlockRootFirstSingleTxReturnType, + RollupBlockRootMsgsOnlyReturnType, RollupBlockRootReturnType, RollupBlockRootSingleTxReturnType, RollupCheckpointMergeReturnType, @@ -74,27 +76,33 @@ import type { DecodedInputs } from '../utils/decoded_inputs.js'; export { mapAvmCircuitPublicInputsToNoir } from '../conversion/server.js'; /** - * Converts the inputs of the base parity circuit into a witness map. - * @param inputs - The base parity inputs. + * Converts the inputs of the inbox parity circuit into a witness map. + * @param inputs - The inbox parity inputs. * @returns The witness map */ -export function convertParityBasePrivateInputsToWitnessMap( - inputs: ParityBasePrivateInputs, +export function convertInboxParityPrivateInputsToWitnessMap( + inputs: InboxParityPrivateInputs, simulated = false, ): WitnessMap { - return convertPrivateInputsToWitnessMap('ParityBaseArtifact', mapParityBasePrivateInputsToNoir(inputs), simulated); + return convertPrivateInputsToWitnessMap( + inboxParityArtifactForSize(inputs.size), + mapInboxParityPrivateInputsToNoir(inputs), + simulated, + ); } -/** - * Converts the inputs of the root parity circuit into a witness map. - * @param inputs - The root parity inputs. - * @returns The witness map - */ -export function convertParityRootPrivateInputsToWitnessMap( - inputs: ParityRootPrivateInputs, - simulated = false, -): WitnessMap { - return convertPrivateInputsToWitnessMap('ParityRootArtifact', mapParityRootPrivateInputsToNoir(inputs), simulated); +/** Maps an InboxParity ladder size to its server artifact. */ +export function inboxParityArtifactForSize(size: number): ServerProtocolArtifact { + switch (size) { + case INBOX_PARITY_SIZE_SMALL: + return 'InboxParity64Artifact'; + case INBOX_PARITY_SIZE_MEDIUM: + return 'InboxParity256Artifact'; + case INBOX_PARITY_SIZE_LARGE: + return 'InboxParity1024Artifact'; + default: + throw new Error(`No InboxParity artifact for size ${size}`); + } } export function convertPublicChonkVerifierPrivateInputsToWitnessMap( @@ -201,6 +209,17 @@ export function convertBlockRootSingleTxRollupPrivateInputsToWitnessMap( ); } +export function convertBlockRootMsgsOnlyRollupPrivateInputsToWitnessMap( + inputs: BlockRootMsgsOnlyRollupPrivateInputs, + simulated = false, +): WitnessMap { + return convertPrivateInputsToWitnessMap( + 'BlockRootMsgsOnlyRollupArtifact', + mapBlockRootMsgsOnlyRollupPrivateInputsToNoir(inputs), + simulated, + ); +} + export function convertBlockMergeRollupPrivateInputsToWitnessMap( inputs: BlockMergeRollupPrivateInputs, simulated = false, @@ -370,6 +389,18 @@ export function convertBlockRootSingleTxRollupOutputsFromWitnessMap( return mapBlockRollupPublicInputsFromNoir(publicInputs); } +export function convertBlockRootMsgsOnlyRollupOutputsFromWitnessMap( + outputs: WitnessMap, + simulated = false, +): BlockRollupPublicInputs { + const publicInputs = convertOutputsFromWitnessMap( + 'BlockRootMsgsOnlyRollupArtifact', + outputs, + simulated, + ); + return mapBlockRollupPublicInputsFromNoir(publicInputs); +} + export function convertBlockMergeRollupOutputsFromWitnessMap( outputs: WitnessMap, simulated = false, @@ -441,22 +472,21 @@ export function convertRootRollupOutputsFromWitnessMap(outputs: WitnessMap, simu } /** - * Converts the outputs of the base parity circuit from a witness map. - * @param outputs - The base parity outputs as a witness map. + * Converts the outputs of the inbox parity circuit from a witness map. + * @param outputs - The inbox parity outputs as a witness map. * @returns The public inputs. */ -export function convertParityBaseOutputsFromWitnessMap(outputs: WitnessMap, simulated = false): ParityPublicInputs { - const publicInputs = convertOutputsFromWitnessMap('ParityBaseArtifact', outputs, simulated); - return mapParityPublicInputsFromNoir(publicInputs); -} - -/** - * Converts the outputs of the root parity circuit from a witness map. - * @param outputs - The root parity outputs as a witness map. - * @returns The public inputs. - */ -export function convertParityRootOutputsFromWitnessMap(outputs: WitnessMap, simulated = false): ParityPublicInputs { - const publicInputs = convertOutputsFromWitnessMap('ParityRootArtifact', outputs, simulated); +export function convertInboxParityOutputsFromWitnessMap( + outputs: WitnessMap, + size: number, + simulated = false, +): ParityPublicInputs { + // Every ladder size shares the same `ParityPublicInputs` return ABI, so the decode is identical across sizes. + const publicInputs = convertOutputsFromWitnessMap( + inboxParityArtifactForSize(size), + outputs, + simulated, + ); return mapParityPublicInputsFromNoir(publicInputs); } diff --git a/yarn-project/noir-protocol-circuits-types/src/scripts/generate_ts_from_abi.ts b/yarn-project/noir-protocol-circuits-types/src/scripts/generate_ts_from_abi.ts index 8cca923f21ef..79a3ba4f4b00 100644 --- a/yarn-project/noir-protocol-circuits-types/src/scripts/generate_ts_from_abi.ts +++ b/yarn-project/noir-protocol-circuits-types/src/scripts/generate_ts_from_abi.ts @@ -8,8 +8,9 @@ import { promises as fs } from 'fs'; const log = createConsoleLogger('autogenerate'); const circuits = [ - 'parity_base', - 'parity_root', + 'inbox_parity_64', + 'inbox_parity_256', + 'inbox_parity_1024', 'private_kernel_init', 'private_kernel_init_2', 'private_kernel_init_3', @@ -34,6 +35,7 @@ const circuits = [ 'rollup_block_root_first', 'rollup_block_root_first_single_tx', 'rollup_block_root_first_empty_tx', + 'rollup_block_root_msgs_only', 'rollup_block_merge', 'rollup_checkpoint_root', 'rollup_checkpoint_root_single_block', diff --git a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.bench.test.ts b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.bench.test.ts index a12f1f88723b..36319604383b 100644 --- a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.bench.test.ts +++ b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.bench.test.ts @@ -151,6 +151,7 @@ describe('LightweightCheckpointBuilder benchmarks', () => { constants, [], [], + Fr.ZERO, fork, ); diff --git a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.test.ts b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.test.ts index b10d906cd0e7..d7f607bd5f19 100644 --- a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.test.ts +++ b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.test.ts @@ -108,6 +108,7 @@ describe('LightweightCheckpointBuilder', () => { constants, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, fork, ); @@ -148,6 +149,7 @@ describe('LightweightCheckpointBuilder', () => { constants, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, fork, ); @@ -198,6 +200,7 @@ describe('LightweightCheckpointBuilder', () => { constants, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, fork, ); @@ -237,6 +240,7 @@ describe('LightweightCheckpointBuilder', () => { constants, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, fork, ); @@ -290,6 +294,7 @@ describe('LightweightCheckpointBuilder', () => { constants, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, fork, ); @@ -314,6 +319,7 @@ describe('LightweightCheckpointBuilder', () => { constants, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, fork, ); @@ -348,6 +354,7 @@ describe('LightweightCheckpointBuilder', () => { constants, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, fork, ); diff --git a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts index 10a2865cda4b..59176228a08c 100644 --- a/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts +++ b/yarn-project/prover-client/src/light/lightweight_checkpoint_builder.ts @@ -8,6 +8,7 @@ import { Checkpoint } from '@aztec/stdlib/checkpoint'; import type { MerkleTreeWriteOperations } from '@aztec/stdlib/interfaces/server'; import { accumulateCheckpointOutHashes, + accumulateInboxRollingHash, appendL1ToL2MessagesToTree, computeCheckpointOutHash, computeInHashFromL1ToL2Messages, @@ -47,6 +48,8 @@ export class LightweightCheckpointBuilder { public feeAssetPriceModifier: bigint, public readonly l1ToL2Messages: Fr[], private readonly previousCheckpointOutHashes: Fr[], + // Inbox rolling hash of the previous checkpoint (this checkpoint's chain start); genesis is zero. + private readonly previousInboxRollingHash: Fr, public readonly db: MerkleTreeWriteOperations, bindings?: LoggerBindings, ) { @@ -63,6 +66,7 @@ export class LightweightCheckpointBuilder { constants: CheckpointGlobalVariables, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], + previousInboxRollingHash: Fr, db: MerkleTreeWriteOperations, bindings?: LoggerBindings, feeAssetPriceModifier: bigint = 0n, @@ -76,6 +80,7 @@ export class LightweightCheckpointBuilder { feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, db, bindings, ); @@ -93,6 +98,7 @@ export class LightweightCheckpointBuilder { feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], + previousInboxRollingHash: Fr, db: MerkleTreeWriteOperations, existingBlocks: L2Block[], bindings?: LoggerBindings, @@ -103,6 +109,7 @@ export class LightweightCheckpointBuilder { feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, db, bindings, ); @@ -264,6 +271,7 @@ export class LightweightCheckpointBuilder { const blobsHash = computeBlobsHashFromBlobs(blobs); const inHash = computeInHashFromL1ToL2Messages(this.l1ToL2Messages); + const inboxRollingHash = accumulateInboxRollingHash(this.previousInboxRollingHash, this.l1ToL2Messages); const { slotNumber, coinbase, feeRecipient, gasFees } = this.constants; const checkpointOutHash = computeCheckpointOutHash( @@ -281,6 +289,7 @@ export class LightweightCheckpointBuilder { lastArchiveRoot: this.lastArchives[0].root, blobsHash, inHash, + inboxRollingHash, epochOutHash, blockHeadersHash, slotNumber, @@ -310,6 +319,7 @@ export class LightweightCheckpointBuilder { this.feeAssetPriceModifier, [...this.l1ToL2Messages], [...this.previousCheckpointOutHashes], + this.previousInboxRollingHash, this.db, this.logger.getBindings(), ); diff --git a/yarn-project/prover-client/src/mocks/test_context.ts b/yarn-project/prover-client/src/mocks/test_context.ts index 5c709bdbf8e4..657a4cf97268 100644 --- a/yarn-project/prover-client/src/mocks/test_context.ts +++ b/yarn-project/prover-client/src/mocks/test_context.ts @@ -249,6 +249,7 @@ export class TestContext { { ...constants, timestamp }, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, cleanFork, ); diff --git a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts index 53c7a594db82..83c7ed4bdf14 100644 --- a/yarn-project/prover-client/src/orchestrator/block-proving-state.ts +++ b/yarn-project/prover-client/src/orchestrator/block-proving-state.ts @@ -1,17 +1,18 @@ import { type BlockBlobData, type BlockEndBlobData, type SpongeBlob, encodeBlockEndBlobData } from '@aztec/blob-lib'; import { type ARCHIVE_HEIGHT, + L1_TO_L2_MSG_SUBTREE_HEIGHT, type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, - NESTED_RECURSIVE_PROOF_LENGTH, + type L1_TO_L2_MSG_TREE_HEIGHT, + MAX_L1_TO_L2_MSGS_PER_BLOCK, type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, - NUM_BASE_PARITY_PER_ROOT_PARITY, } from '@aztec/constants'; import { BlockNumber } from '@aztec/foundation/branded-types'; import { Fr } from '@aztec/foundation/curves/bn254'; -import { type Tuple, assertLength } from '@aztec/foundation/serialize'; +import type { Tuple } from '@aztec/foundation/serialize'; import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees'; import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server'; -import { type ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity'; +import { L1ToL2MessageBundle } from '@aztec/stdlib/messaging'; import type { RollupHonkProofData } from '@aztec/stdlib/proofs'; import { BlockRollupPublicInputs, @@ -38,6 +39,17 @@ export type ProofState = { isProving?: boolean; }; +/** + * The block-root rollup flavor a block proves with and its private inputs, discriminated by circuit name so callers + * can dispatch to the matching prover entrypoint with the correctly-typed inputs. + */ +export type BlockRootRollupTypeAndInputs = + | { rollupType: 'rollup-block-root-first'; inputs: BlockRootFirstRollupPrivateInputs } + | { rollupType: 'rollup-block-root-first-single-tx'; inputs: BlockRootSingleTxFirstRollupPrivateInputs } + | { rollupType: 'rollup-block-root-first-empty-tx'; inputs: BlockRootEmptyTxFirstRollupPrivateInputs } + | { rollupType: 'rollup-block-root-single-tx'; inputs: BlockRootSingleTxRollupPrivateInputs } + | { rollupType: 'rollup-block-root'; inputs: BlockRootRollupPrivateInputs }; + /** * The current state of the proving schedule for a given block. Managed by ProvingState. * Contains the raw inputs and intermediate state to generate every constituent proof in the tree. @@ -46,11 +58,6 @@ export class BlockProvingState { private baseOrMergeProofs: UnbalancedTreeStore< ProofState > = new UnbalancedTreeStore(0); - private baseParityProofs: (ProofState | undefined)[] = - Array.from({ - length: NUM_BASE_PARITY_PER_ROOT_PARITY, - }).map(_ => undefined); - private rootParityProof: ProofState | undefined; private blockRootProof: | ProofState | undefined; @@ -148,38 +155,6 @@ export class BlockProvingState { this.baseOrMergeProofs.setNode(location, { provingOutput }); } - public tryStartProvingBaseParity(index: number) { - if (this.baseParityProofs[index]?.isProving) { - return false; - } else { - this.baseParityProofs[index] = { isProving: true }; - return true; - } - } - - // Stores a set of root parity inputs at the given index - public setBaseParityProof(index: number, provingOutput: PublicInputsAndRecursiveProof) { - if (index >= NUM_BASE_PARITY_PER_ROOT_PARITY) { - throw new Error( - `Unable to set a base parity proofs at index ${index}. Expected at most ${NUM_BASE_PARITY_PER_ROOT_PARITY} proofs.`, - ); - } - this.baseParityProofs[index] = { provingOutput }; - } - - public tryStartProvingRootParity() { - if (this.rootParityProof?.isProving) { - return false; - } else { - this.rootParityProof = { isProving: true }; - return true; - } - } - - public setRootParityProof(provingOutput: PublicInputsAndRecursiveProof) { - this.rootParityProof = { provingOutput }; - } - public tryStartProvingBlockRoot() { if (this.blockRootProof?.isProving) { return false; @@ -316,7 +291,7 @@ export class BlockProvingState { return new TxMergeRollupPrivateInputs([toProofData(left), toProofData(right)]); } - public getBlockRootRollupTypeAndInputs() { + public getBlockRootRollupTypeAndInputs(): BlockRootRollupTypeAndInputs { const provingOutputs = this.#getChildProvingOutputsForBlockRoot(); if (!provingOutputs.every(p => !!p)) { throw new Error('At least one child is not ready for the block root rollup.'); @@ -328,36 +303,55 @@ export class BlockProvingState { return this.#getFirstBlockRootRollupTypeAndInputs(previousRollups); } + const messageBundle = this.#getMessageBundle(); + const frontierHint = this.#getFrontierHint(); + const startMsgSponge = this.parentCheckpoint.getCheckpointMsgSponge(); + const [leftRollup, rightRollup] = previousRollups; if (!rightRollup) { return { rollupType: 'rollup-block-root-single-tx' satisfies CircuitName, - inputs: new BlockRootSingleTxRollupPrivateInputs(leftRollup, this.lastArchiveSiblingPath), + inputs: new BlockRootSingleTxRollupPrivateInputs( + leftRollup, + messageBundle, + this.lastL1ToL2MessageTreeSnapshot, + startMsgSponge, + frontierHint, + this.lastArchiveSiblingPath, + ), }; } else { return { rollupType: 'rollup-block-root' satisfies CircuitName, - inputs: new BlockRootRollupPrivateInputs([leftRollup, rightRollup], this.lastArchiveSiblingPath), + inputs: new BlockRootRollupPrivateInputs( + [leftRollup, rightRollup], + messageBundle, + this.lastL1ToL2MessageTreeSnapshot, + startMsgSponge, + frontierHint, + this.lastArchiveSiblingPath, + ), }; } } - #getFirstBlockRootRollupTypeAndInputs([leftRollup, rightRollup]: RollupHonkProofData[]) { - if (!this.rootParityProof?.provingOutput) { - throw new Error('Root parity is not ready.'); - } - const l1ToL2Roots = toProofData(this.rootParityProof.provingOutput); + #getFirstBlockRootRollupTypeAndInputs([ + leftRollup, + rightRollup, + ]: RollupHonkProofData[]): BlockRootRollupTypeAndInputs { + const messageBundle = this.#getMessageBundle(); + const frontierHint = this.#getFrontierHint(); if (!leftRollup) { return { rollupType: 'rollup-block-root-first-empty-tx' satisfies CircuitName, inputs: new BlockRootEmptyTxFirstRollupPrivateInputs( - l1ToL2Roots, this.lastArchiveTreeSnapshot, this.headerOfLastBlockInPreviousCheckpoint.state, this.constants, this.timestamp, - this.lastL1ToL2MessageSubtreeRootSiblingPath, + messageBundle, + frontierHint, this.lastArchiveSiblingPath, ), }; @@ -365,10 +359,10 @@ export class BlockProvingState { return { rollupType: 'rollup-block-root-first-single-tx' satisfies CircuitName, inputs: new BlockRootSingleTxFirstRollupPrivateInputs( - l1ToL2Roots, leftRollup, + messageBundle, this.lastL1ToL2MessageTreeSnapshot, - this.lastL1ToL2MessageSubtreeRootSiblingPath, + frontierHint, this.lastArchiveSiblingPath, ), }; @@ -376,24 +370,43 @@ export class BlockProvingState { return { rollupType: 'rollup-block-root-first' satisfies CircuitName, inputs: new BlockRootFirstRollupPrivateInputs( - l1ToL2Roots, [leftRollup, rightRollup], + messageBundle, this.lastL1ToL2MessageTreeSnapshot, - this.lastL1ToL2MessageSubtreeRootSiblingPath, + frontierHint, this.lastArchiveSiblingPath, ), }; } } - public getParityRootInputs() { - const baseParityProvingOutputs = this.baseParityProofs.filter(p => !!p?.provingOutput).map(p => p!.provingOutput!); - if (baseParityProvingOutputs.length !== this.baseParityProofs.length) { - throw new Error('At lease one base parity is not ready.'); + /** + * The message bundle this block appends. Transitionally the first block carries the whole checkpoint's messages + * padded to `MAX_L1_TO_L2_MSGS_PER_BLOCK` — inserted as a full aligned subtree into the L1-to-L2 tree (`numMsgs` = + * the cap), while only the real messages are absorbed into the message sponge (`numRealMsgs`, matching the + * checkpoint's InboxParity proof). Non-first blocks carry an empty bundle. + */ + #getMessageBundle(): L1ToL2MessageBundle { + if (this.isFirstBlock) { + return new L1ToL2MessageBundle( + this.parentCheckpoint.getPaddedL1ToL2Messages(), + MAX_L1_TO_L2_MSGS_PER_BLOCK, + this.parentCheckpoint.getNumRealL1ToL2Messages(), + ); } + return L1ToL2MessageBundle.empty(); + } - const children = baseParityProvingOutputs.map(p => toProofData(p)); - return new ParityRootPrivateInputs(assertLength(children, NUM_BASE_PARITY_PER_ROOT_PARITY)); + /** + * Full-height frontier hint for the bundle append. The l1-to-l2 tree index is always subtree-aligned in the + * transitional wiring, so the bottom `L1_TO_L2_MSG_SUBTREE_HEIGHT` levels are left-child (unread, zero) and the top + * levels are exactly the subtree-root sibling path already captured for this block. + */ + #getFrontierHint(): Tuple { + return [ + ...Array.from({ length: L1_TO_L2_MSG_SUBTREE_HEIGHT }, () => Fr.ZERO), + ...this.lastL1ToL2MessageSubtreeRootSiblingPath, + ] as Tuple; } // Returns a specific transaction proving state @@ -413,15 +426,11 @@ export class BlockProvingState { return !!this.baseOrMergeProofs.getSibling(location)?.provingOutput; } - // Returns true if we have sufficient inputs to execute the block root rollup + // Returns true if we have sufficient inputs to execute the block root rollup. Parity no longer gates the block root + // (it moved to the checkpoint root), so the block root is ready once its child tx proofs land. public isReadyForBlockRootRollup() { const childProofs = this.#getChildProvingOutputsForBlockRoot(); - return (!this.isFirstBlock || !!this.rootParityProof?.provingOutput) && childProofs.every(p => !!p); - } - - // Returns true if we have sufficient root parity inputs to execute the root parity circuit - public isReadyForRootParity() { - return this.baseParityProofs.every(p => !!p?.provingOutput); + return childProofs.every(p => !!p); } public isComplete() { diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts index af04c8ebd55d..128c44f980a0 100644 --- a/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts +++ b/yarn-project/prover-client/src/orchestrator/checkpoint-proving-state.ts @@ -1,17 +1,17 @@ import { SpongeBlob } from '@aztec/blob-lib'; -import { - type ARCHIVE_HEIGHT, - type L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, - type NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, - NUM_MSGS_PER_BASE_PARITY, +import type { + ARCHIVE_HEIGHT, + L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, + NESTED_RECURSIVE_PROOF_LENGTH, + NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, } from '@aztec/constants'; import { BlockNumber } from '@aztec/foundation/branded-types'; -import { padArrayEnd } from '@aztec/foundation/collection'; import { Fr } from '@aztec/foundation/curves/bn254'; import type { Tuple } from '@aztec/foundation/serialize'; import { type TreeNodeLocation, UnbalancedTreeStore } from '@aztec/foundation/trees'; import type { PublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server'; -import { ParityBasePrivateInputs } from '@aztec/stdlib/parity'; +import { L1ToL2MessageSponge, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging'; +import { InboxParityPrivateInputs, type ParityPublicInputs } from '@aztec/stdlib/parity'; import { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, CheckpointConstantData } from '@aztec/stdlib/rollup'; import type { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees'; import type { BlockHeader } from '@aztec/stdlib/tx'; @@ -24,6 +24,10 @@ export class CheckpointProvingState { private blockProofs: UnbalancedTreeStore< ProofState >; + // The checkpoint's single InboxParity proof. Parity gates the checkpoint root, not the first block root: one + // variable-size proof per checkpoint replaces the former base + root parity fan-in. Surfaced as part of the + // sub-tree result. + private inboxParityProof: ProofState | undefined; private blocks: (BlockProvingState | undefined)[] = []; private error: string | undefined; public readonly firstBlockNumber: BlockNumber; @@ -35,6 +39,9 @@ export class CheckpointProvingState { private readonly headerOfLastBlockInPreviousCheckpoint: BlockHeader, private readonly lastArchiveSiblingPath: Tuple, private readonly l1ToL2Messages: Fr[], + // Inbox rolling hash before this checkpoint's messages (the previous checkpoint's end value; genesis is zero). + // Threaded into the InboxParity circuit so the resulting checkpoint header rolling hash matches the proposer's. + private readonly startInboxRollingHash: Fr, // The snapshot and sibling path before the new l1 to l2 message subtree is inserted. private readonly lastL1ToL2MessageTreeSnapshot: AppendOnlyTreeSnapshot, private readonly lastL1ToL2MessageSubtreeRootSiblingPath: Tuple< @@ -47,6 +54,13 @@ export class CheckpointProvingState { Fr, typeof L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH >, + // The checkpoint's messages padded to `MAX_L1_TO_L2_MSGS_PER_CHECKPOINT` (the first block's transitional bundle, + // inserted as a full subtree into the L1-to-L2 tree). + private readonly paddedL1ToL2Messages: Fr[], + // Message-bundle sponge over the checkpoint's real messages (real-count absorb). Equals the InboxParity proof's + // end sponge and the sponge the block roots accumulate, so it is threaded into non-first block roots as their + // inherited `startMsgSponge`. + private readonly checkpointMsgSponge: L1ToL2MessageSponge, public readonly epochNumber: number, /** Owner's liveness check. `verifyState()` returns false once this returns false. */ private readonly isAlive: () => boolean, @@ -57,6 +71,21 @@ export class CheckpointProvingState { this.firstBlockNumber = BlockNumber(headerOfLastBlockInPreviousCheckpoint.globalVariables.blockNumber + 1); } + /** The checkpoint's messages padded to the per-checkpoint cap (the first block's transitional bundle). */ + public getPaddedL1ToL2Messages(): Fr[] { + return this.paddedL1ToL2Messages; + } + + /** Number of real (non-padding) L1-to-L2 messages in the checkpoint — the sponge/InboxParity real-count. */ + public getNumRealL1ToL2Messages(): number { + return this.l1ToL2Messages.length; + } + + /** The message-bundle sponge over the checkpoint's real messages (real-count absorb) — inherited by non-first block roots. */ + public getCheckpointMsgSponge(): L1ToL2MessageSponge { + return this.checkpointMsgSponge; + } + public startNewBlock( blockNumber: BlockNumber, timestamp: UInt64, @@ -138,16 +167,38 @@ export class CheckpointProvingState { this.blockProofs.setNode(location, { provingOutput }); } - public getBaseParityInputs(baseParityIndex: number) { - const messages = padArrayEnd( - this.l1ToL2Messages.slice( - baseParityIndex * NUM_MSGS_PER_BASE_PARITY, - (baseParityIndex + 1) * NUM_MSGS_PER_BASE_PARITY, - ), - Fr.ZERO, - NUM_MSGS_PER_BASE_PARITY, + // ---------------- inbox parity proof orchestration ---------------- + + /** + * Builds the checkpoint's single InboxParity input. The circuit is sized to the smallest ladder rung that fits the + * message count; the rolling hash starts from the previous checkpoint's end and the message sponge starts empty (it + * resets per checkpoint). `in_hash` (the L1 frontier root) is supplied as an unconstrained pass-through hint. + */ + public getInboxParityInputs(): InboxParityPrivateInputs { + return InboxParityPrivateInputs.fromMessages( + this.l1ToL2Messages, + this.startInboxRollingHash, + L1ToL2MessageSponge.empty(), + computeInHashFromL1ToL2Messages(this.l1ToL2Messages), + this.constants.vkTreeRoot, + this.constants.proverId, ); - return new ParityBasePrivateInputs(messages, this.constants.vkTreeRoot, this.constants.proverId); + } + + public tryStartProvingInboxParity() { + if (this.inboxParityProof?.isProving) { + return false; + } + this.inboxParityProof = { isProving: true }; + return true; + } + + public setInboxParityProof(provingOutput: PublicInputsAndRecursiveProof) { + this.inboxParityProof = { provingOutput }; + } + + public getInboxParityProof() { + return this.inboxParityProof?.provingOutput; } public getParentLocation(location: TreeNodeLocation) { diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.test.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.test.ts index e0b48d2559b6..703aa7ec9b8b 100644 --- a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.test.ts +++ b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.test.ts @@ -1,6 +1,7 @@ import { MAX_L2_TO_L1_MSGS_PER_TX } from '@aztec/constants'; import { EpochNumber } from '@aztec/foundation/branded-types'; import { padArrayEnd } from '@aztec/foundation/collection'; +import { Fr } from '@aztec/foundation/curves/bn254'; import { EthAddress } from '@aztec/foundation/eth-address'; import { createLogger } from '@aztec/foundation/log'; import { ScopedL2ToL1Message, computeBlockOutHash } from '@aztec/stdlib/messaging'; @@ -50,6 +51,7 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => { makeTestDeferredJobQueue(), constants, l1ToL2Messages, + Fr.ZERO, numBlocks, previousBlockHeader, ); @@ -68,6 +70,10 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => { const result = await resultPromise; expect(result.blockProofOutputs).toHaveLength(1); expect(result.blockProofOutputs[0].proof).toBeDefined(); + // Parity gates the checkpoint root: the sub-tree proves it once per checkpoint and surfaces it for the top tree + // to feed into the checkpoint root rollup. + expect(result.inboxParityProof).toBeDefined(); + expect(result.inboxParityProof.proof).toBeDefined(); expect(result.previousArchiveSiblingPath).toBeDefined(); } finally { await subTree.stop(); @@ -91,6 +97,7 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => { makeTestDeferredJobQueue(), constants, l1ToL2Messages, + Fr.ZERO, numBlocks, previousBlockHeader, ); @@ -108,6 +115,8 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => { const result = await resultPromise; expect(result.blockProofOutputs).toHaveLength(2); + // A single parity root proof covers the whole checkpoint, regardless of block count. + expect(result.inboxParityProof).toBeDefined(); } finally { await subTree.stop(); } @@ -133,6 +142,7 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => { makeTestDeferredJobQueue(), constants, l1ToL2Messages, + Fr.ZERO, numBlocks, previousBlockHeader, ); @@ -180,6 +190,7 @@ describe('prover/orchestrator/checkpoint-sub-tree', () => { makeTestDeferredJobQueue(), constants, l1ToL2Messages, + Fr.ZERO, numBlocks, previousBlockHeader, ); diff --git a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts index c3d0c0e39806..ff6fe49b580f 100644 --- a/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts +++ b/yarn-project/prover-client/src/orchestrator/checkpoint-sub-tree-orchestrator.ts @@ -3,10 +3,11 @@ import { type ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, + MAX_L1_TO_L2_MSGS_PER_CHECKPOINT, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, - NUM_BASE_PARITY_PER_ROOT_PARITY, } from '@aztec/constants'; import { BlockNumber, type EpochNumber } from '@aztec/foundation/branded-types'; +import { padArrayEnd } from '@aztec/foundation/collection'; import { Fr } from '@aztec/foundation/curves/bn254'; import { AbortError } from '@aztec/foundation/error'; import type { LoggerBindings } from '@aztec/foundation/log'; @@ -22,14 +23,11 @@ import type { ReadonlyWorldStateAccess, ServerCircuitProver, } from '@aztec/stdlib/interfaces/server'; -import { appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging'; +import { L1ToL2MessageSponge, appendL1ToL2MessagesToTree } from '@aztec/stdlib/messaging'; +import type { ParityPublicInputs } from '@aztec/stdlib/parity'; import { type BaseRollupHints, type BlockRollupPublicInputs, - BlockRootEmptyTxFirstRollupPrivateInputs, - BlockRootFirstRollupPrivateInputs, - BlockRootSingleTxFirstRollupPrivateInputs, - BlockRootSingleTxRollupPrivateInputs, CheckpointConstantData, PrivateTxBaseRollupPrivateInputs, type PublicChonkVerifierPublicInputs, @@ -79,9 +77,20 @@ export type SubTreeResult = { BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH >[]; + /** + * The checkpoint's single InboxParity proof. Parity gates the checkpoint root rather than the first block root, so + * the sub-tree proves it and hands it to the top tree, which feeds it into the checkpoint root rollup. + */ + inboxParityProof: PublicInputsAndRecursiveProof; previousArchiveSiblingPath: Tuple; }; +/** + * The proofs a checkpoint's sub-tree hands to the top tree: the per-block rollup proofs plus the checkpoint's single + * variable-size InboxParity proof. + */ +export type CheckpointSubTreeProofs = Pick; + type TreeSnapshots = Map; /** @@ -192,6 +201,7 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { deferredJobQueue: SerialQueue, checkpointConstants: CheckpointConstantData, l1ToL2Messages: Fr[], + startInboxRollingHash: Fr, totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader, telemetryClient: TelemetryClient = getTelemetryClient(), @@ -212,6 +222,7 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { await subTree.startCheckpoint( checkpointConstants, l1ToL2Messages, + startInboxRollingHash, totalNumBlocks, headerOfLastBlockInPreviousCheckpoint, ); @@ -288,13 +299,6 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { lastArchiveSiblingPath, ); - // Enqueue base parity circuits for the first block in the checkpoint. - if (blockProvingState.index === 0) { - for (let i = 0; i < NUM_BASE_PARITY_PER_ROOT_PARITY; i++) { - this.enqueueBaseParityCircuit(this.provingState, blockProvingState, i); - } - } - // Because `addTxs` won't be called for a block without txs, and that's where the sponge blob state is computed, // set its end sponge blob here. This becomes the start sponge blob for the next block. if (totalNumTxs === 0) { @@ -305,6 +309,12 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { const blockEndBlobFields = blockProvingState.getBlockEndBlobFields(); await endSpongeBlob.absorb(blockEndBlobFields); blockProvingState.setEndSpongeBlob(endSpongeBlob); + + // A block with no txs has no base or merge proof whose completion would enqueue its block root, + // and parity now gates the checkpoint root rather than the first block root, so no other callback + // fires it. Enqueue it here. Only a first block may be empty (the block proving state rejects + // any other), so this always drives the empty-tx first block root. + this.checkAndEnqueueBlockRootRollup(blockProvingState); } } @@ -493,6 +503,7 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { private async startCheckpoint( constants: CheckpointConstantData, l1ToL2Messages: Fr[], + startInboxRollingHash: Fr, totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader, ): Promise { @@ -518,6 +529,13 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { newL1ToL2MessageSubtreeRootSiblingPath, } = await this.updateL1ToL2MessageTree(l1ToL2Messages, db); + // The first block inserts the whole checkpoint's messages as a full padded subtree into the L1-to-L2 tree, so keep + // the padded array for the block-root bundle. The message sponge, however, absorbs only the real messages + // (real-count), so it matches the checkpoint's single InboxParity proof; non-first block roots inherit this sponge. + const paddedL1ToL2Messages = padArrayEnd(l1ToL2Messages, Fr.ZERO, MAX_L1_TO_L2_MSGS_PER_CHECKPOINT); + const checkpointMsgSponge = L1ToL2MessageSponge.empty(); + await checkpointMsgSponge.absorb(l1ToL2Messages); + this.provingState = new CheckpointProvingState( /* index */ 0, constants, @@ -525,14 +543,21 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { headerOfLastBlockInPreviousCheckpoint, lastArchiveSiblingPath, l1ToL2Messages, + startInboxRollingHash, lastL1ToL2MessageTreeSnapshot, lastL1ToL2MessageSubtreeRootSiblingPath, newL1ToL2MessageTreeSnapshot, newL1ToL2MessageSubtreeRootSiblingPath, + paddedL1ToL2Messages, + checkpointMsgSponge, Number(this.epochNumber), /* isAlive */ () => !this.cancelled, /* onReject */ reason => this.subTreeResult.reject(new Error(reason)), ); + + // Parity now gates the checkpoint root (not the first block root); prove the single sized InboxParity per + // checkpoint up front. + this.enqueueInboxParityCircuit(this.provingState); } // ---------------- private: per-block proof orchestration ---------------- @@ -730,7 +755,9 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { return; } - const { rollupType, inputs } = provingState.getBlockRootRollupTypeAndInputs(); + // Kept whole (not destructured) so the switch on the `rollupType` discriminant narrows `inputs` per case. + const rollup = provingState.getBlockRootRollupTypeAndInputs(); + const rollupType = rollup.rollupType; this.logger.debug(`Enqueuing ${rollupType} for block ${provingState.blockNumber}.`); @@ -739,16 +766,17 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { this.wrapCircuitCall( 'getBlockRootRollupProof', signal => { - if (inputs instanceof BlockRootFirstRollupPrivateInputs) { - return this.prover.getBlockRootFirstRollupProof(inputs, signal, provingState.epochNumber); - } else if (inputs instanceof BlockRootSingleTxFirstRollupPrivateInputs) { - return this.prover.getBlockRootSingleTxFirstRollupProof(inputs, signal, provingState.epochNumber); - } else if (inputs instanceof BlockRootEmptyTxFirstRollupPrivateInputs) { - return this.prover.getBlockRootEmptyTxFirstRollupProof(inputs, signal, provingState.epochNumber); - } else if (inputs instanceof BlockRootSingleTxRollupPrivateInputs) { - return this.prover.getBlockRootSingleTxRollupProof(inputs, signal, provingState.epochNumber); - } else { - return this.prover.getBlockRootRollupProof(inputs, signal, provingState.epochNumber); + switch (rollup.rollupType) { + case 'rollup-block-root-first': + return this.prover.getBlockRootFirstRollupProof(rollup.inputs, signal, provingState.epochNumber); + case 'rollup-block-root-first-single-tx': + return this.prover.getBlockRootSingleTxFirstRollupProof(rollup.inputs, signal, provingState.epochNumber); + case 'rollup-block-root-first-empty-tx': + return this.prover.getBlockRootEmptyTxFirstRollupProof(rollup.inputs, signal, provingState.epochNumber); + case 'rollup-block-root-single-tx': + return this.prover.getBlockRootSingleTxRollupProof(rollup.inputs, signal, provingState.epochNumber); + case 'rollup-block-root': + return this.prover.getBlockRootRollupProof(rollup.inputs, signal, provingState.epochNumber); } }, { [Attributes.PROTOCOL_CIRCUIT_NAME]: rollupType }, @@ -776,70 +804,32 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { ); } - // Executes the base parity circuit. Enqueues the root parity circuit if all inputs are available. - private enqueueBaseParityCircuit( - checkpointProvingState: CheckpointProvingState, - provingState: BlockProvingState, - baseParityIndex: number, - ) { - if (!provingState.verifyState()) { - this.logger.debug('Not running base parity. State no longer valid.'); + // Runs the checkpoint's single InboxParity circuit and stores the output. The proof feeds the checkpoint root (in + // the top tree), so completing it may resolve the sub-tree rather than a block root. + private enqueueInboxParityCircuit(checkpointProvingState: CheckpointProvingState) { + if (!checkpointProvingState.verifyState()) { + this.logger.debug('Not running inbox parity. State no longer valid.'); return; } - if (!provingState.tryStartProvingBaseParity(baseParityIndex)) { - this.logger.warn(`Base parity ${baseParityIndex} already started.`); + if (!checkpointProvingState.tryStartProvingInboxParity()) { + this.logger.debug('Inbox parity already started.'); return; } - const inputs = checkpointProvingState.getBaseParityInputs(baseParityIndex); + const inputs = checkpointProvingState.getInboxParityInputs(); + const circuitName = `inbox-parity-${inputs.size}` satisfies CircuitName; this.deferredProving( - provingState, + checkpointProvingState, this.wrapCircuitCall( - 'getBaseParityProof', - signal => this.prover.getBaseParityProof(inputs, signal, provingState.epochNumber), - { [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-base' satisfies CircuitName }, - ), - provingOutput => { - provingState.setBaseParityProof(baseParityIndex, provingOutput); - this.checkAndEnqueueRootParityCircuit(provingState); - }, - ); - } - - private checkAndEnqueueRootParityCircuit(provingState: BlockProvingState) { - if (!provingState.isReadyForRootParity()) { - return; - } - this.enqueueRootParityCircuit(provingState); - } - - // Runs the root parity circuit and stores the outputs. - // Enqueues the block root rollup if all inputs are available. - private enqueueRootParityCircuit(provingState: BlockProvingState) { - if (!provingState.verifyState()) { - this.logger.debug('Not running root parity. State no longer valid.'); - return; - } - - if (!provingState.tryStartProvingRootParity()) { - this.logger.debug('Root parity already started.'); - return; - } - - const inputs = provingState.getParityRootInputs(); - - this.deferredProving( - provingState, - this.wrapCircuitCall( - 'getRootParityProof', - signal => this.prover.getRootParityProof(inputs, signal, provingState.epochNumber), - { [Attributes.PROTOCOL_CIRCUIT_NAME]: 'parity-root' satisfies CircuitName }, + 'getInboxParityProof', + signal => this.prover.getInboxParityProof(inputs, signal, checkpointProvingState.epochNumber), + { [Attributes.PROTOCOL_CIRCUIT_NAME]: circuitName }, ), result => { - provingState.setRootParityProof(result); - this.checkAndEnqueueBlockRootRollup(provingState); + checkpointProvingState.setInboxParityProof(result); + this.checkAndEnqueueSubTreeResolution(checkpointProvingState); }, ); } @@ -923,8 +913,15 @@ export class CheckpointSubTreeOrchestrator extends ProvingScheduler { // Block merge tree not fully resolved yet — retried as more block proofs land. return; } + // The InboxParity proof gates the sub-tree result too (it feeds the checkpoint root in the top tree). + const inboxParityProof = provingState.getInboxParityProof(); + if (!inboxParityProof) { + // Parity not proven yet — retried when the inbox parity proof lands. + return; + } this.subTreeResult.resolve({ blockProofOutputs: nonEmpty, + inboxParityProof, previousArchiveSiblingPath: provingState.getLastArchiveSiblingPath(), }); } diff --git a/yarn-project/prover-client/src/orchestrator/index.ts b/yarn-project/prover-client/src/orchestrator/index.ts index 9fe9f502a7be..f2585a33f1a7 100644 --- a/yarn-project/prover-client/src/orchestrator/index.ts +++ b/yarn-project/prover-client/src/orchestrator/index.ts @@ -1,4 +1,8 @@ -export { CheckpointSubTreeOrchestrator, type SubTreeResult } from './checkpoint-sub-tree-orchestrator.js'; +export { + CheckpointSubTreeOrchestrator, + type CheckpointSubTreeProofs, + type SubTreeResult, +} from './checkpoint-sub-tree-orchestrator.js'; export { ChonkCache, type ChonkVerifierProofResult } from './chonk-cache.js'; export { TopTreeOrchestrator, diff --git a/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.test.ts b/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.test.ts index 9be914f034b2..74a3ad8e554c 100644 --- a/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.test.ts +++ b/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.test.ts @@ -1,6 +1,7 @@ import { MAX_L2_TO_L1_MSGS_PER_TX } from '@aztec/constants'; import { EpochNumber } from '@aztec/foundation/branded-types'; import { padArrayEnd } from '@aztec/foundation/collection'; +import { Fr } from '@aztec/foundation/curves/bn254'; import { EthAddress } from '@aztec/foundation/eth-address'; import { createLogger } from '@aztec/foundation/log'; import { promiseWithResolvers } from '@aztec/foundation/promise'; @@ -65,6 +66,7 @@ describe('prover/orchestrator/top-tree', () => { makeTestDeferredJobQueue(), fixture.constants, fixture.l1ToL2Messages, + Fr.ZERO, numBlocks, fixture.previousBlockHeader, ); @@ -83,7 +85,10 @@ describe('prover/orchestrator/top-tree', () => { await subTree.stop(); const topTreeData: CheckpointTopTreeData = { - blockProofs: Promise.resolve(result.blockProofOutputs), + subTreeProofs: Promise.resolve({ + blockProofOutputs: result.blockProofOutputs, + inboxParityProof: result.inboxParityProof, + }), l2ToL1MsgsPerBlock: fixture.blocks.map(b => b.txs.map(tx => tx.txEffect.l2ToL1Msgs)), blobFields: fixture.checkpoint.toBlobFields(), previousBlockHeader: fixture.previousBlockHeader, @@ -165,9 +170,9 @@ describe('prover/orchestrator/top-tree', () => { const b = await driveSubTree(1, 1); const challenges = await context.getFinalBlobChallenges(); - // Replace ckpt1's blockProofs with a deferred promise that resolves later. - const deferred = promiseWithResolvers ? T : never>(); - const ckpt1 = { ...b.topTreeData, blockProofs: deferred.promise } as CheckpointTopTreeData; + // Replace ckpt1's subTreeProofs with a deferred promise that resolves later. + const deferred = promiseWithResolvers ? T : never>(); + const ckpt1 = { ...b.topTreeData, subTreeProofs: deferred.promise } as CheckpointTopTreeData; const topTree = new TopTreeOrchestrator(context.prover, EthAddress.ZERO, makeTestDeferredJobQueue()); try { @@ -179,7 +184,7 @@ describe('prover/orchestrator/top-tree', () => { await new Promise(resolve => setTimeout(resolve, 50)); // Now resolve ckpt1 — the orchestrator should pick it up and continue. - deferred.resolve((await b.topTreeData.blockProofs) as any); + deferred.resolve((await b.topTreeData.subTreeProofs) as any); const result = await provePromise; expect(result.proof).toBeDefined(); @@ -192,9 +197,9 @@ describe('prover/orchestrator/top-tree', () => { const { topTreeData } = await driveSubTree(1, 1); const challenges = await context.getFinalBlobChallenges(); - // Block ckpt0's blockProofs forever so prove() can't finish. - const stuck = new Promise ? T : never>(() => {}); - const stuckData = { ...topTreeData, blockProofs: stuck } as CheckpointTopTreeData; + // Block ckpt0's subTreeProofs forever so prove() can't finish. + const stuck = new Promise ? T : never>(() => {}); + const stuckData = { ...topTreeData, subTreeProofs: stuck } as CheckpointTopTreeData; const topTree = new TopTreeOrchestrator(context.prover, EthAddress.ZERO, makeTestDeferredJobQueue()); const provePromise = topTree.prove(EpochNumber(1), 1, challenges, [stuckData]); @@ -251,7 +256,10 @@ describe('prover/orchestrator/top-tree', () => { const challenges = await context.getFinalBlobChallenges(); // A malformed block proof makes toProofData (inside buildCheckpointRootInputs) throw. - const badData = { ...topTreeData, blockProofs: Promise.resolve([{} as any]) } as CheckpointTopTreeData; + const badData = { + ...topTreeData, + subTreeProofs: Promise.resolve({ blockProofOutputs: [{} as any], inboxParityProof: {} as any }), + } as CheckpointTopTreeData; const topTree = new TopTreeOrchestrator(context.prover, EthAddress.ZERO, makeTestDeferredJobQueue()); try { @@ -280,23 +288,23 @@ describe('prover/orchestrator/top-tree', () => { const { topTreeData } = await driveSubTree(1, 1); const challenges = await context.getFinalBlobChallenges(); - const deferred = promiseWithResolvers ? T : never>(); - // Observe exactly when prove() attaches its blockProofs handler, so we can sequence the + const deferred = promiseWithResolvers ? T : never>(); + // Observe exactly when prove() attaches its subTreeProofs handler, so we can sequence the // genuine rejection and the cancel deterministically rather than racing a fixed timeout. let handlerAttached = false; - const observableBlockProofs = { + const observableSubTreeProofs = { then: (onF: any, onR: any) => { handlerAttached = true; return deferred.promise.then(onF, onR); }, }; - const failingData = { ...topTreeData, blockProofs: observableBlockProofs as any } as CheckpointTopTreeData; + const failingData = { ...topTreeData, subTreeProofs: observableSubTreeProofs as any } as CheckpointTopTreeData; const topTree = new TopTreeOrchestrator(context.prover, EthAddress.ZERO, makeTestDeferredJobQueue()); const provePromise = topTree.prove(EpochNumber(1), 1, challenges, [failingData]); - // Wait until prove() has finished its pre-loop setup and registered the blockProofs handler. - await retryUntil(() => handlerAttached, 'prove() attaches blockProofs handler', 5, 0.005); + // Wait until prove() has finished its pre-loop setup and registered the subTreeProofs handler. + await retryUntil(() => handlerAttached, 'prove() attaches subTreeProofs handler', 5, 0.005); // Register a cancel reaction on the rejection, after prove()'s own handler (registered // first, so it runs first). On rejection the ordering is: prove's handler rejects the diff --git a/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.ts b/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.ts index 5c3d9e66bc39..eccd4340328f 100644 --- a/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.ts +++ b/yarn-project/prover-client/src/orchestrator/top-tree-orchestrator.ts @@ -19,6 +19,7 @@ import { MerkleTreeCalculator, type TreeNodeLocation, shaMerkleHash } from '@azt import type { EthAddress } from '@aztec/stdlib/block'; import type { PublicInputsAndRecursiveProof, ServerCircuitProver } from '@aztec/stdlib/interfaces/server'; import { computeCheckpointOutHash } from '@aztec/stdlib/messaging'; +import type { ParityPublicInputs } from '@aztec/stdlib/parity'; import type { Proof } from '@aztec/stdlib/proofs'; import { type BlockRollupPublicInputs, @@ -32,19 +33,18 @@ import type { BlockHeader } from '@aztec/stdlib/tx'; import { type TelemetryClient, getTelemetryClient } from '@aztec/telemetry-client'; import { buildBlobHints, toProofData } from './block-building-helpers.js'; +import type { CheckpointSubTreeProofs } from './checkpoint-sub-tree-orchestrator.js'; import { ProvingScheduler } from './proving-scheduler.js'; import { TopTreeProvingState } from './top-tree-proving-state.js'; /** Per-checkpoint data fed into the top tree. */ export type CheckpointTopTreeData = { /** - * Block-rollup proof outputs from the checkpoint's sub-tree. Passed as a Promise so the - * top tree can start (compute hints, pipeline merges) while sub-trees are still proving. - * The promise resolves to 1 entry for a single-block checkpoint, 2 for multi-block. + * The checkpoint sub-tree's proofs. Passed as a Promise so the top tree can start (compute hints, pipeline merges) + * while sub-trees are still proving. `blockProofOutputs` resolves to 1 entry for a single-block checkpoint, 2 for + * multi-block; `inboxParityProof` feeds the checkpoint root rollup. */ - blockProofs: Promise< - PublicInputsAndRecursiveProof[] - >; + subTreeProofs: Promise; /** L2-to-L1 messages per block in the checkpoint, used to compute the out hash. */ l2ToL1MsgsPerBlock: Fr[][][]; /** Blob fields encoding the checkpoint's tx effects, used to compute the blob accumulator. */ @@ -84,7 +84,7 @@ type OutHashHint = { * * Pipelined start: `prove()` does not wait for block-level proving. It pre-computes the * out-hash and blob-accumulator hint chains immediately from archiver-derivable data, - * and each checkpoint's root rollup fires the moment its sub-tree's `blockProofs` + * and each checkpoint's root rollup fires the moment its sub-tree's `subTreeProofs` * promise resolves. Later checkpoints can still be block-level proving in parallel. */ export class TopTreeOrchestrator extends ProvingScheduler { @@ -166,15 +166,16 @@ export class TopTreeOrchestrator extends ProvingScheduler { for (let i = 0; i < checkpointData.length; i++) { const cd = checkpointData[i]; const checkpointIndex = i; - void cd.blockProofs.then( - blockProofs => { + void cd.subTreeProofs.then( + subTreeProofs => { if (this.cancelled || !this.state?.verifyState()) { return; } this.enqueueCheckpointRoot( this.state, checkpointIndex, - blockProofs, + subTreeProofs.blockProofOutputs, + subTreeProofs.inboxParityProof, cd, outHashHints[i], checkpointStartBlobs[i], @@ -220,15 +221,22 @@ export class TopTreeOrchestrator extends ProvingScheduler { private enqueueCheckpointRoot( state: TopTreeProvingState, checkpointIndex: number, - blockProofs: PublicInputsAndRecursiveProof< + blockProofOutputs: PublicInputsAndRecursiveProof< BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH >[], + inboxParityProof: PublicInputsAndRecursiveProof, cd: CheckpointTopTreeData, outHashHint: OutHashHint, startBlobAccumulator: BatchedBlobAccumulator, ) { - void this.buildCheckpointRootInputs(blockProofs, cd, outHashHint, startBlobAccumulator).then( + void this.buildCheckpointRootInputs( + blockProofOutputs, + inboxParityProof, + cd, + outHashHint, + startBlobAccumulator, + ).then( inputs => { this.deferredProving( state, @@ -261,10 +269,11 @@ export class TopTreeOrchestrator extends ProvingScheduler { } private async buildCheckpointRootInputs( - blockProofs: PublicInputsAndRecursiveProof< + blockProofOutputs: PublicInputsAndRecursiveProof< BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH >[], + inboxParityProof: PublicInputsAndRecursiveProof, cd: CheckpointTopTreeData, outHashHint: OutHashHint, startBlobAccumulator: BatchedBlobAccumulator, @@ -283,10 +292,11 @@ export class TopTreeOrchestrator extends ProvingScheduler { blobsHash, }); - const proofDatas = blockProofs.map(p => toProofData(p)); + const inboxParity = toProofData(inboxParityProof); + const proofDatas = blockProofOutputs.map(p => toProofData(p)); return proofDatas.length === 1 - ? new CheckpointRootSingleBlockRollupPrivateInputs(proofDatas[0], hints) - : new CheckpointRootRollupPrivateInputs([proofDatas[0], proofDatas[1]], hints); + ? new CheckpointRootSingleBlockRollupPrivateInputs(proofDatas[0], inboxParity, hints) + : new CheckpointRootRollupPrivateInputs([proofDatas[0], proofDatas[1]], inboxParity, hints); } // --- internal: top-tree proof orchestration (formerly TopTreeProvingScheduler) --- diff --git a/yarn-project/prover-client/src/prover-client/prover-client.ts b/yarn-project/prover-client/src/prover-client/prover-client.ts index f8260d704fbc..c9040b46b685 100644 --- a/yarn-project/prover-client/src/prover-client/prover-client.ts +++ b/yarn-project/prover-client/src/prover-client/prover-client.ts @@ -56,6 +56,7 @@ export interface EpochProverFactory { epochNumber: EpochNumber, checkpointConstants: CheckpointConstantData, l1ToL2Messages: Fr[], + startInboxRollingHash: Fr, totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader, ): Promise; @@ -133,6 +134,7 @@ export class ProverClient implements EpochProverManager, EpochProverFactory { epochNumber: EpochNumber, checkpointConstants: CheckpointConstantData, l1ToL2Messages: Fr[], + startInboxRollingHash: Fr, totalNumBlocks: number, headerOfLastBlockInPreviousCheckpoint: BlockHeader, ): Promise { @@ -146,6 +148,7 @@ export class ProverClient implements EpochProverManager, EpochProverFactory { this.getDeferredJobQueue(), checkpointConstants, l1ToL2Messages, + startInboxRollingHash, totalNumBlocks, headerOfLastBlockInPreviousCheckpoint, this.telemetry, diff --git a/yarn-project/prover-client/src/proving_broker/broker_prover_facade.test.ts b/yarn-project/prover-client/src/proving_broker/broker_prover_facade.test.ts index c73b1789583a..ce8dd828fc29 100644 --- a/yarn-project/prover-client/src/proving_broker/broker_prover_facade.test.ts +++ b/yarn-project/prover-client/src/proving_broker/broker_prover_facade.test.ts @@ -4,7 +4,7 @@ import { promiseWithResolvers } from '@aztec/foundation/promise'; import { retryFastUntil } from '@aztec/foundation/retry'; import { type ProvingJobStatus, makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server'; import { makeRecursiveProof } from '@aztec/stdlib/proofs'; -import { makeParityBasePrivateInputs, makeParityPublicInputs } from '@aztec/stdlib/testing'; +import { makeInboxParityPrivateInputs, makeParityPublicInputs } from '@aztec/stdlib/testing'; import { VerificationKeyData } from '@aztec/stdlib/vks'; import { jest } from '@jest/globals'; @@ -40,33 +40,33 @@ describe('BrokerCircuitProverFacade', () => { }); it('sends jobs to the broker', async () => { - const inputs = makeParityBasePrivateInputs(); + const inputs = makeInboxParityPrivateInputs(); const controller = new AbortController(); jest.spyOn(broker, 'enqueueProvingJob'); - jest.spyOn(prover, 'getBaseParityProof'); + jest.spyOn(prover, 'getInboxParityProof'); jest.spyOn(errorProofStore, 'saveProofInput'); - await expect(facade.getBaseParityProof(inputs, controller.signal, EpochNumber(42))).resolves.toBeDefined(); + await expect(facade.getInboxParityProof(inputs, controller.signal, EpochNumber(42))).resolves.toBeDefined(); expect(broker.enqueueProvingJob).toHaveBeenCalled(); - expect(prover.getBaseParityProof).toHaveBeenCalledWith(inputs, expect.anything(), EpochNumber(42)); + expect(prover.getInboxParityProof).toHaveBeenCalledWith(inputs, expect.anything(), EpochNumber(42)); expect(errorProofStore.saveProofInput).not.toHaveBeenCalled(); }); it('handles multiple calls for the same job', async () => { - const inputs = makeParityBasePrivateInputs(); + const inputs = makeInboxParityPrivateInputs(); const controller = new AbortController(); const promises: Promise[] = []; const resultPromise = promiseWithResolvers(); jest.spyOn(broker, 'enqueueProvingJob'); - jest.spyOn(prover, 'getBaseParityProof').mockReturnValue(resultPromise.promise); + jest.spyOn(prover, 'getInboxParityProof').mockReturnValue(resultPromise.promise); // send N identical proof requests const CALLS = 50; for (let i = 0; i < CALLS; i++) { - promises.push(facade.getBaseParityProof(inputs, controller.signal, EpochNumber(42))); + promises.push(facade.getInboxParityProof(inputs, controller.signal, EpochNumber(42))); } // now we have 50 promises all waiting on the same result @@ -83,11 +83,11 @@ describe('BrokerCircuitProverFacade', () => { // the broker will only have been told about one of the calls expect(broker.enqueueProvingJob).toHaveBeenCalledTimes(1); - expect(prover.getBaseParityProof).toHaveBeenCalledWith(inputs, expect.anything(), EpochNumber(42)); + expect(prover.getInboxParityProof).toHaveBeenCalledWith(inputs, expect.anything(), EpochNumber(42)); // enqueue another N requests for the same jobs for (let i = 0; i < CALLS; i++) { - promises.push(facade.getBaseParityProof(inputs, controller.signal, EpochNumber(42))); + promises.push(facade.getInboxParityProof(inputs, controller.signal, EpochNumber(42))); } await Promise.all(promises); @@ -95,7 +95,7 @@ describe('BrokerCircuitProverFacade', () => { // the broker will have received one new request expect(broker.enqueueProvingJob).toHaveBeenCalledTimes(2); // but no new jobs where created - expect(prover.getBaseParityProof).toHaveBeenCalledTimes(1); + expect(prover.getInboxParityProof).toHaveBeenCalledTimes(1); // and all requests will have been resolved with the same result for (const promise of promises) { @@ -104,23 +104,23 @@ describe('BrokerCircuitProverFacade', () => { }); it('handles proof errors', async () => { - const inputs = makeParityBasePrivateInputs(); + const inputs = makeInboxParityPrivateInputs(); const controller = new AbortController(); const promises: Promise[] = []; const resultPromise = promiseWithResolvers(); jest.spyOn(broker, 'enqueueProvingJob'); - const getBaseParityProofSpy = jest.spyOn(prover, 'getBaseParityProof').mockReturnValue(resultPromise.promise); + const getInboxParityProofSpy = jest.spyOn(prover, 'getInboxParityProof').mockReturnValue(resultPromise.promise); jest.spyOn(errorProofStore, 'saveProofInput'); // send N identical proof requests const CALLS = 50; for (let i = 0; i < CALLS; i++) { // wrap the error in a resolved promises so that we don't have unhandled rejections - promises.push(facade.getBaseParityProof(inputs, controller.signal, EpochNumber(42)).catch(err => ({ err }))); + promises.push(facade.getInboxParityProof(inputs, controller.signal, EpochNumber(42)).catch(err => ({ err }))); } - await retryFastUntil(() => getBaseParityProofSpy.mock.calls.length > 0, 'prover to be called'); + await retryFastUntil(() => getInboxParityProofSpy.mock.calls.length > 0, 'prover to be called'); resultPromise.reject(new Error('TEST ERROR')); @@ -129,11 +129,11 @@ describe('BrokerCircuitProverFacade', () => { // the broker should only have been called once expect(broker.enqueueProvingJob).toHaveBeenCalledTimes(1); - expect(prover.getBaseParityProof).toHaveBeenCalledWith(inputs, expect.anything(), EpochNumber(42)); + expect(prover.getInboxParityProof).toHaveBeenCalledWith(inputs, expect.anything(), EpochNumber(42)); // enqueue another N requests for the same jobs for (let i = 0; i < CALLS; i++) { - promises.push(facade.getBaseParityProof(inputs, controller.signal, EpochNumber(42)).catch(err => ({ err }))); + promises.push(facade.getInboxParityProof(inputs, controller.signal, EpochNumber(42)).catch(err => ({ err }))); } // and all 2 * N requests will have been resolved with the same result @@ -144,23 +144,23 @@ describe('BrokerCircuitProverFacade', () => { // the broker will have received one new request expect(broker.enqueueProvingJob).toHaveBeenCalledTimes(2); // but no new jobs where created - expect(prover.getBaseParityProof).toHaveBeenCalledTimes(1); + expect(prover.getInboxParityProof).toHaveBeenCalledTimes(1); // and the proof input will have been backed up expect(errorProofStore.saveProofInput).toHaveBeenCalled(); }); it('handles aborts', async () => { - const inputs = makeParityBasePrivateInputs(); + const inputs = makeInboxParityPrivateInputs(); const controller = new AbortController(); const resultPromise = promiseWithResolvers(); jest.spyOn(broker, 'enqueueProvingJob'); - const getBaseParityProofSpy = jest.spyOn(prover, 'getBaseParityProof').mockReturnValue(resultPromise.promise); + const getInboxParityProofSpy = jest.spyOn(prover, 'getInboxParityProof').mockReturnValue(resultPromise.promise); jest.spyOn(errorProofStore, 'saveProofInput'); - const promise = facade.getBaseParityProof(inputs, controller.signal, EpochNumber(42)).catch(err => ({ err })); + const promise = facade.getInboxParityProof(inputs, controller.signal, EpochNumber(42)).catch(err => ({ err })); - await retryFastUntil(() => getBaseParityProofSpy.mock.calls.length > 0, 'prover to be called'); + await retryFastUntil(() => getInboxParityProofSpy.mock.calls.length > 0, 'prover to be called'); controller.abort(); @@ -169,14 +169,14 @@ describe('BrokerCircuitProverFacade', () => { }); it('rejects jobs when the facade is stopped', async () => { - const inputs = makeParityBasePrivateInputs(); + const inputs = makeInboxParityPrivateInputs(); const controller = new AbortController(); const resultPromise = promiseWithResolvers(); jest.spyOn(broker, 'enqueueProvingJob'); - jest.spyOn(prover, 'getBaseParityProof').mockReturnValue(resultPromise.promise); + jest.spyOn(prover, 'getInboxParityProof').mockReturnValue(resultPromise.promise); - const promise = facade.getBaseParityProof(inputs, controller.signal, EpochNumber(42)).catch(err => ({ err })); + const promise = facade.getInboxParityProof(inputs, controller.signal, EpochNumber(42)).catch(err => ({ err })); await facade.stop(); @@ -185,13 +185,13 @@ describe('BrokerCircuitProverFacade', () => { // Regression test for #13166 it('handles stopping while sending a proof to the broker', async () => { - const inputs = makeParityBasePrivateInputs(); + const inputs = makeInboxParityPrivateInputs(); const controller = new AbortController(); // make sure the job hangs on waiting for the broker const enqueueJobPromise = promiseWithResolvers(); const enqueueProvingJobSpy = jest.spyOn(broker, 'enqueueProvingJob').mockReturnValue(enqueueJobPromise.promise); - const promise = facade.getBaseParityProof(inputs, controller.signal, EpochNumber(42)); + const promise = facade.getInboxParityProof(inputs, controller.signal, EpochNumber(42)); // now stop the facade after giving it time, which will trigger a rejection await retryFastUntil(() => enqueueProvingJobSpy.mock.calls.length > 0, 'broker to be called'); diff --git a/yarn-project/prover-client/src/proving_broker/broker_prover_facade.ts b/yarn-project/prover-client/src/proving_broker/broker_prover_facade.ts index acb80833f38f..3aa04785f558 100644 --- a/yarn-project/prover-client/src/proving_broker/broker_prover_facade.ts +++ b/yarn-project/prover-client/src/proving_broker/broker_prover_facade.ts @@ -1,6 +1,5 @@ import type { AVM_V2_PROOF_LENGTH_IN_FIELDS, - NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, } from '@aztec/constants'; @@ -22,13 +21,14 @@ import { type ServerCircuitProver, makeProvingJobId, } from '@aztec/stdlib/interfaces/server'; -import type { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity'; +import type { InboxParityPrivateInputs, ParityPublicInputs } from '@aztec/stdlib/parity'; import { ProvingRequestType, RecursiveProof } from '@aztec/stdlib/proofs'; import type { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, + BlockRootMsgsOnlyRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, @@ -406,14 +406,14 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver { ); } - getBaseParityProof( - inputs: ParityBasePrivateInputs, + getInboxParityProof( + inputs: InboxParityPrivateInputs, signal?: AbortSignal, epochNumber?: EpochNumber, ): Promise> { return this.enqueueJob( - this.generateId(ProvingRequestType.PARITY_BASE, inputs, epochNumber), - ProvingRequestType.PARITY_BASE, + this.generateId(ProvingRequestType.INBOX_PARITY, inputs, epochNumber), + ProvingRequestType.INBOX_PARITY, inputs, epochNumber, signal, @@ -478,20 +478,6 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver { ); } - getRootParityProof( - inputs: ParityRootPrivateInputs, - signal?: AbortSignal, - epochNumber?: EpochNumber, - ): Promise> { - return this.enqueueJob( - this.generateId(ProvingRequestType.PARITY_ROOT, inputs, epochNumber), - ProvingRequestType.PARITY_ROOT, - inputs, - epochNumber, - signal, - ); - } - getBlockRootFirstRollupProof( input: BlockRootFirstRollupPrivateInputs, signal?: AbortSignal, @@ -534,6 +520,20 @@ export class BrokerCircuitProverFacade implements ServerCircuitProver { ); } + getBlockRootMsgsOnlyRollupProof( + input: BlockRootMsgsOnlyRollupPrivateInputs, + signal?: AbortSignal, + epochNumber?: EpochNumber, + ): Promise> { + return this.enqueueJob( + this.generateId(ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP, input, epochNumber), + ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP, + input, + epochNumber, + signal, + ); + } + getBlockRootRollupProof( input: BlockRootRollupPrivateInputs, signal?: AbortSignal, diff --git a/yarn-project/prover-client/src/proving_broker/fixtures.ts b/yarn-project/prover-client/src/proving_broker/fixtures.ts index ac1a5e3ddc89..9dea2a5c70dd 100644 --- a/yarn-project/prover-client/src/proving_broker/fixtures.ts +++ b/yarn-project/prover-client/src/proving_broker/fixtures.ts @@ -6,7 +6,7 @@ import { ProvingRequestType } from '@aztec/stdlib/proofs'; export function makeRandomProvingJobId(epochNumber?: EpochNumber): ProvingJobId { return makeProvingJobId( epochNumber ?? EpochNumber(1), - ProvingRequestType.PARITY_BASE, + ProvingRequestType.INBOX_PARITY, randomBytes(8).toString('hex'), ); } diff --git a/yarn-project/prover-client/src/proving_broker/proving_agent.test.ts b/yarn-project/prover-client/src/proving_broker/proving_agent.test.ts index d366982152d3..9403d7793dc2 100644 --- a/yarn-project/prover-client/src/proving_broker/proving_agent.test.ts +++ b/yarn-project/prover-client/src/proving_broker/proving_agent.test.ts @@ -15,7 +15,7 @@ import { } from '@aztec/stdlib/interfaces/server'; import type { ParityPublicInputs } from '@aztec/stdlib/parity'; import { ProvingRequestType, makeRecursiveProof } from '@aztec/stdlib/proofs'; -import { makeParityBasePrivateInputs, makeParityPublicInputs } from '@aztec/stdlib/testing'; +import { makeInboxParityPrivateInputs, makeParityPublicInputs } from '@aztec/stdlib/testing'; import { VerificationKeyData } from '@aztec/stdlib/vks'; import { jest } from '@jest/globals'; @@ -49,7 +49,7 @@ describe('ProvingAgent', () => { saveProofOutput: jest.fn(() => Promise.resolve('' as ProofUri)), }; - allowList = [ProvingRequestType.PARITY_BASE]; + allowList = [ProvingRequestType.INBOX_PARITY]; agent = new ProvingAgent(jobSource, proofDB, prover, allowList, agentPollIntervalMs); }); @@ -59,7 +59,7 @@ describe('ProvingAgent', () => { it('polls for jobs passing the permitted list of proofs', () => { agent.start(); - expect(jobSource.getProvingJob).toHaveBeenCalledWith({ allowList: [ProvingRequestType.PARITY_BASE] }); + expect(jobSource.getProvingJob).toHaveBeenCalledWith({ allowList: [ProvingRequestType.INBOX_PARITY] }); }); it('only takes a single job from the source at a time', async () => { @@ -68,7 +68,7 @@ describe('ProvingAgent', () => { // simulate the proof taking a long time const { promise, resolve } = promiseWithResolvers>(); - jest.spyOn(prover, 'getBaseParityProof').mockReturnValueOnce(promise); + jest.spyOn(prover, 'getInboxParityProof').mockReturnValueOnce(promise); const { job, time, inputs } = makeBaseParityJob(); jobSource.getProvingJob.mockResolvedValueOnce({ job, time }); @@ -103,7 +103,7 @@ describe('ProvingAgent', () => { const { job, time, inputs } = makeBaseParityJob(); const result = makeBaseParityResult(); - jest.spyOn(prover, 'getBaseParityProof').mockResolvedValueOnce(result); + jest.spyOn(prover, 'getInboxParityProof').mockResolvedValueOnce(result); jobSource.getProvingJob.mockResolvedValueOnce({ job, time }); proofDB.getProofInput.mockResolvedValueOnce(inputs); @@ -118,7 +118,7 @@ describe('ProvingAgent', () => { it('reports errors to the job source', async () => { const { job, time, inputs } = makeBaseParityJob(); - jest.spyOn(prover, 'getBaseParityProof').mockRejectedValueOnce(new Error('test error')); + jest.spyOn(prover, 'getInboxParityProof').mockRejectedValueOnce(new Error('test error')); jobSource.getProvingJob.mockResolvedValueOnce({ job, time }); proofDB.getProofInput.mockResolvedValueOnce(inputs); @@ -133,7 +133,7 @@ describe('ProvingAgent', () => { it('sets the retry flag on when reporting an error', async () => { const { job, time, inputs } = makeBaseParityJob(); const err = new ProvingError('test error', undefined, true); - jest.spyOn(prover, 'getBaseParityProof').mockRejectedValueOnce(err); + jest.spyOn(prover, 'getInboxParityProof').mockRejectedValueOnce(err); jobSource.getProvingJob.mockResolvedValueOnce({ job, time }); proofDB.getProofInput.mockResolvedValueOnce(inputs); @@ -149,7 +149,7 @@ describe('ProvingAgent', () => { const { job, time, inputs } = makeBaseParityJob(); const { promise, resolve } = promiseWithResolvers>(); - jest.spyOn(prover, 'getBaseParityProof').mockReturnValueOnce(promise); + jest.spyOn(prover, 'getInboxParityProof').mockReturnValueOnce(promise); jobSource.getProvingJob.mockResolvedValueOnce({ job, time }); proofDB.getProofInput.mockResolvedValueOnce(inputs); @@ -157,12 +157,12 @@ describe('ProvingAgent', () => { await jest.advanceTimersByTimeAsync(agentPollIntervalMs); expect(jobSource.reportProvingJobProgress).toHaveBeenCalledWith(job.id, time, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }); await jest.advanceTimersByTimeAsync(agentPollIntervalMs); expect(jobSource.reportProvingJobProgress).toHaveBeenCalledWith(job.id, time, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }); resolve(makeBaseParityResult()); @@ -175,7 +175,7 @@ describe('ProvingAgent', () => { promiseWithResolvers>(); // simulate a long running proving job that can be aborted - jest.spyOn(prover, 'getBaseParityProof').mockImplementationOnce((_, signal) => { + jest.spyOn(prover, 'getInboxParityProof').mockImplementationOnce((_, signal) => { signal?.addEventListener('abort', () => { firstProof.reject(new AbortError('test abort')); firstProofAborted = true; @@ -191,7 +191,7 @@ describe('ProvingAgent', () => { await jest.advanceTimersByTimeAsync(agentPollIntervalMs); expect(jobSource.reportProvingJobProgress).toHaveBeenCalledTimes(1); expect(jobSource.reportProvingJobProgress).toHaveBeenCalledWith(firstJob.job.id, firstJob.time, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }); await jest.advanceTimersByTimeAsync(agentPollIntervalMs); @@ -205,21 +205,21 @@ describe('ProvingAgent', () => { const secondProof = promiseWithResolvers>(); - jest.spyOn(prover, 'getBaseParityProof').mockReturnValueOnce(secondProof.promise); + jest.spyOn(prover, 'getInboxParityProof').mockReturnValueOnce(secondProof.promise); jobSource.reportProvingJobProgress.mockResolvedValueOnce(secondJobResponse); await jest.advanceTimersByTimeAsync(agentPollIntervalMs); expect(jobSource.reportProvingJobProgress).toHaveBeenCalledTimes(4); expect(jobSource.reportProvingJobProgress).toHaveBeenNthCalledWith(3, firstJob.job.id, firstJob.time, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }); expect(jobSource.reportProvingJobProgress).toHaveBeenNthCalledWith( 4, secondJobResponse.job.id, secondJobResponse.time, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }, ); expect(firstProofAborted).toBe(true); @@ -231,7 +231,7 @@ describe('ProvingAgent', () => { secondJobResponse.job.id, secondJobResponse.time, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }, ); }); @@ -241,7 +241,7 @@ describe('ProvingAgent', () => { const job2 = makeBaseParityJob(); jest - .spyOn(prover, 'getBaseParityProof') + .spyOn(prover, 'getInboxParityProof') .mockResolvedValueOnce(makeBaseParityResult()) .mockResolvedValueOnce(makeBaseParityResult()); @@ -265,7 +265,7 @@ describe('ProvingAgent', () => { const job2 = makeBaseParityJob(); jest - .spyOn(prover, 'getBaseParityProof') + .spyOn(prover, 'getInboxParityProof') .mockRejectedValueOnce(new Error('test error')) .mockResolvedValueOnce(makeBaseParityResult()); @@ -297,11 +297,11 @@ describe('ProvingAgent', () => { function makeBaseParityJob(): { job: ProvingJob; time: number; inputs: ProvingJobInputs } { const time = jest.now(); - const inputs: ProvingJobInputs = { type: ProvingRequestType.PARITY_BASE, inputs: makeParityBasePrivateInputs() }; + const inputs: ProvingJobInputs = { type: ProvingRequestType.INBOX_PARITY, inputs: makeInboxParityPrivateInputs() }; const job: ProvingJob = { id: randomBytes(8).toString('hex') as ProvingJobId, epochNumber: EpochNumber(1), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: randomBytes(8).toString('hex') as ProofUri, }; diff --git a/yarn-project/prover-client/src/proving_broker/proving_broker.test.ts b/yarn-project/prover-client/src/proving_broker/proving_broker.test.ts index ca5cb0be1851..79060fa85a53 100644 --- a/yarn-project/prover-client/src/proving_broker/proving_broker.test.ts +++ b/yarn-project/prover-client/src/proving_broker/proving_broker.test.ts @@ -83,7 +83,7 @@ describe.each([ await broker.enqueueProvingJob({ id, epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); expect(await broker.getProvingJobStatus(id)).toEqual({ status: 'in-queue' }); @@ -105,7 +105,7 @@ describe.each([ const enqueueStatus = await broker.enqueueProvingJob({ id, epochNumber: EpochNumber(1), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); expect(enqueueStatus).toEqual({ status: 'not-found' }); @@ -125,7 +125,7 @@ describe.each([ it('ignores duplicate jobs', async () => { const provingJob: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -139,7 +139,7 @@ describe.each([ it('reports correct status when enqueuing repeat jobs', async () => { const provingJob: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -172,14 +172,14 @@ describe.each([ await broker.enqueueProvingJob({ id, epochNumber: EpochNumber(1), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); await expect( broker.enqueueProvingJob({ id, epochNumber: EpochNumber(1), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }), ).rejects.toThrow('Duplicate proving job ID'); @@ -195,7 +195,7 @@ describe.each([ await broker.enqueueProvingJob({ id, epochNumber: EpochNumber(1), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); await assertJobStatus(id, 'in-queue'); @@ -209,7 +209,7 @@ describe.each([ await broker.enqueueProvingJob({ id, epochNumber: EpochNumber(1), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); await assertJobStatus(id, 'in-queue'); @@ -222,7 +222,7 @@ describe.each([ it('revives an aborted job when its producer re-requests it', async () => { const provingJob: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -239,7 +239,7 @@ describe.each([ // 'in-queue', and it can then be completed. await expect(broker.enqueueProvingJob(provingJob)).resolves.toEqual({ status: 'in-queue' }); await assertJobStatus(provingJob.id, 'in-queue'); - const returnedJob = await broker.getProvingJob({ allowList: [ProvingRequestType.PARITY_BASE] }); + const returnedJob = await broker.getProvingJob({ allowList: [ProvingRequestType.INBOX_PARITY] }); expect(returnedJob?.job).toEqual(provingJob); const retryValue = makeOutputsUri(); @@ -250,7 +250,7 @@ describe.each([ it('persists the aborted state across a restart and revives on re-request', async () => { const provingJob: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -276,7 +276,7 @@ describe.each([ // 'in-queue' status), and it can be completed. await expect(broker.enqueueProvingJob(provingJob)).resolves.toEqual({ status: 'in-queue' }); await assertJobStatus(provingJob.id, 'in-queue'); - const returnedJob = await broker.getProvingJob({ allowList: [ProvingRequestType.PARITY_BASE] }); + const returnedJob = await broker.getProvingJob({ allowList: [ProvingRequestType.INBOX_PARITY] }); expect(returnedJob?.job).toEqual(provingJob); const value = makeOutputsUri(); @@ -287,7 +287,7 @@ describe.each([ it('persists the revived (non-aborted) state, so a restart mid-revival stays revived', async () => { const provingJob: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -318,7 +318,7 @@ describe.each([ it('revives once when the producer re-requests an aborted job concurrently', async () => { const provingJob: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -338,10 +338,10 @@ describe.each([ expect(second).toEqual({ status: 'in-queue' }); await assertJobStatus(provingJob.id, 'in-queue'); - const returnedJob = await broker.getProvingJob({ allowList: [ProvingRequestType.PARITY_BASE] }); + const returnedJob = await broker.getProvingJob({ allowList: [ProvingRequestType.INBOX_PARITY] }); expect(returnedJob?.job).toEqual(provingJob); await assertJobStatus(provingJob.id, 'in-progress'); - await expect(broker.getProvingJob({ allowList: [ProvingRequestType.PARITY_BASE] })).resolves.toBeUndefined(); + await expect(broker.getProvingJob({ allowList: [ProvingRequestType.INBOX_PARITY] })).resolves.toBeUndefined(); await broker.reportProvingJobSuccess(provingJob.id, makeOutputsUri()); await assertJobStatus(provingJob.id, 'fulfilled'); @@ -350,7 +350,7 @@ describe.each([ it('returns job result if successful', async () => { const provingJob: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -366,7 +366,7 @@ describe.each([ it('returns job error if failed', async () => { const provingJob: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -382,7 +382,7 @@ describe.each([ it('correctly returns job status for concurrent writes', async () => { const job = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(0), inputsUri: makeInputsUri(), }; @@ -394,7 +394,7 @@ describe.each([ promises.push( broker.enqueueProvingJob({ id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(0), inputsUri: makeInputsUri(), }), @@ -403,7 +403,7 @@ describe.each([ promises.push( broker.enqueueProvingJob({ id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(0), inputsUri: makeInputsUri(), }), @@ -420,21 +420,21 @@ describe.each([ describe('Consumer API', () => { it('returns undefined if no jobs are available', async () => { - const provingJob = await broker.getProvingJob({ allowList: [ProvingRequestType.PARITY_BASE] }); + const provingJob = await broker.getProvingJob({ allowList: [ProvingRequestType.INBOX_PARITY] }); expect(provingJob).toBeUndefined(); }); it('returns jobs in priority order', async () => { const provingJob1: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; const provingJob2: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(2), inputsUri: makeInputsUri(), }; @@ -442,13 +442,13 @@ describe.each([ await broker.enqueueProvingJob(provingJob2); await broker.enqueueProvingJob(provingJob1); - await getAndAssertNextJobId(provingJob1.id, ProvingRequestType.PARITY_BASE); + await getAndAssertNextJobId(provingJob1.id, ProvingRequestType.INBOX_PARITY); }); it('returns undefined if no jobs are available for the given allowList', async () => { await broker.enqueueProvingJob({ id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -462,7 +462,7 @@ describe.each([ const baseParity1 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: baseParity1, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -486,19 +486,19 @@ describe.each([ const rootParity1 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: rootParity1, - type: ProvingRequestType.PARITY_ROOT, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); - await getAndAssertNextJobId(baseParity1, ProvingRequestType.PARITY_BASE); + await getAndAssertNextJobId(baseParity1, ProvingRequestType.INBOX_PARITY); }); it('returns the most important job if it is in the allowList', async () => { const baseParity1 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: baseParity1, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -522,24 +522,47 @@ describe.each([ const rootParity1 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: rootParity1, - type: ProvingRequestType.PARITY_ROOT, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); await getAndAssertNextJobId( baseRollup1, - ProvingRequestType.PARITY_BASE, + ProvingRequestType.INBOX_PARITY, ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, - ProvingRequestType.PARITY_ROOT, + ProvingRequestType.INBOX_PARITY, ); }); + it('prefers an older epoch over a higher-priority proof type from a younger epoch', async () => { + const baseRollup2 = makeRandomProvingJobId(); + await broker.enqueueProvingJob({ + id: baseRollup2, + type: ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, + epochNumber: EpochNumber(2), + inputsUri: makeInputsUri(), + }); + + const publicVm1 = makeRandomProvingJobId(); + await broker.enqueueProvingJob({ + id: publicVm1, + type: ProvingRequestType.PUBLIC_VM, + epochNumber: EpochNumber(1), + inputsUri: makeInputsUri(), + }); + + // A lower-priority type from epoch 1 wins over the higher-priority type from epoch 2: the oldest + // epoch's remaining jobs must complete rather than starve behind newer epochs' work. + await getAndAssertNextJobId(publicVm1, ProvingRequestType.PUBLIC_VM, ProvingRequestType.PRIVATE_TX_BASE_ROLLUP); + await getAndAssertNextJobId(baseRollup2, ProvingRequestType.PUBLIC_VM, ProvingRequestType.PRIVATE_TX_BASE_ROLLUP); + }); + it('returns any job if filter is empty', async () => { const baseParity1 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: baseParity1, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -563,7 +586,7 @@ describe.each([ const rootParity1 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: rootParity1, - type: ProvingRequestType.PARITY_ROOT, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -575,7 +598,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -585,12 +608,12 @@ describe.each([ const id2 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: id2, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); await expect( - broker.reportProvingJobSuccess(id, 'result' as ProofUri, { allowList: [ProvingRequestType.PARITY_BASE] }), + broker.reportProvingJobSuccess(id, 'result' as ProofUri, { allowList: [ProvingRequestType.INBOX_PARITY] }), ).resolves.toEqual({ job: expect.objectContaining({ id: id2 }), time: expect.any(Number) }); }); @@ -598,7 +621,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -608,12 +631,12 @@ describe.each([ const id2 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: id2, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); await expect( - broker.reportProvingJobError(id, 'result' as ProofUri, false, { allowList: [ProvingRequestType.PARITY_BASE] }), + broker.reportProvingJobError(id, 'result' as ProofUri, false, { allowList: [ProvingRequestType.INBOX_PARITY] }), ).resolves.toEqual({ job: expect.objectContaining({ id: id2 }), time: expect.any(Number) }); }); @@ -621,7 +644,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -631,12 +654,12 @@ describe.each([ const id2 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: id2, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); await expect( - broker.reportProvingJobError(id, 'result' as ProofUri, true, { allowList: [ProvingRequestType.PARITY_BASE] }), + broker.reportProvingJobError(id, 'result' as ProofUri, true, { allowList: [ProvingRequestType.INBOX_PARITY] }), ).resolves.toEqual({ job: expect.objectContaining({ id: id2 }), time: expect.any(Number) }); }); @@ -644,7 +667,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -656,12 +679,12 @@ describe.each([ const id2 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: id2, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); await expect( - broker.reportProvingJobProgress(id, now(), { allowList: [ProvingRequestType.PARITY_BASE] }), + broker.reportProvingJobProgress(id, now(), { allowList: [ProvingRequestType.INBOX_PARITY] }), ).resolves.toEqual({ job: expect.objectContaining({ id: id2 }), time: expect.any(Number) }); }); @@ -670,14 +693,14 @@ describe.each([ // this test simulates the broker crashing and when it comes back online it has two agents working the same job const job1: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; const job2: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(2), inputsUri: makeInputsUri(), }; @@ -686,7 +709,7 @@ describe.each([ await broker.enqueueProvingJob(job2); const { job: firstAgentJob, time: firstAgentStartedAt } = (await broker.getProvingJob({ - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }))!; expect(firstAgentJob).toEqual(job1); @@ -695,7 +718,7 @@ describe.each([ await sleep(jobTimeoutMs / 2); await expect( broker.reportProvingJobProgress(job1.id, firstAgentStartedAt, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }), ).resolves.toBeUndefined(); @@ -711,7 +734,7 @@ describe.each([ await assertJobStatus(job1.id, 'in-queue'); const { job: secondAgentJob, time: secondAgentStartedAt } = (await broker.getProvingJob({ - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }))!; // should be the same job! @@ -722,14 +745,14 @@ describe.each([ // and it should take over the job from the second agent await expect( broker.reportProvingJobProgress(job1.id, firstAgentStartedAt, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }), ).resolves.toBeUndefined(); // second agent should get a new job now await expect( broker.reportProvingJobProgress(job1.id, secondAgentStartedAt, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }), ).resolves.toEqual({ job: job2, time: expect.any(Number) }); }); @@ -739,14 +762,14 @@ describe.each([ // this test simulates the broker crashing and when it comes back online it has two agents working the same job const job1: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; const job2: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(2), inputsUri: makeInputsUri(), }; @@ -755,7 +778,7 @@ describe.each([ await broker.enqueueProvingJob(job2); const { job: firstAgentJob, time: firstAgentStartedAt } = (await broker.getProvingJob({ - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }))!; expect(firstAgentJob).toEqual(job1); @@ -776,12 +799,12 @@ describe.each([ // and it should take over the job from the second agent await expect( broker.reportProvingJobProgress(job1.id, firstAgentStartedAt, { - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }), ).resolves.toBeUndefined(); const { job: secondAgentJob } = (await broker.getProvingJob({ - allowList: [ProvingRequestType.PARITY_BASE], + allowList: [ProvingRequestType.INBOX_PARITY], }))!; // should be the same job! @@ -795,14 +818,14 @@ describe.each([ // this test simulates the broker crashing and when it comes back online it has two agents working the same job const job1: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; const job2: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(2), inputsUri: makeInputsUri(), }; @@ -839,13 +862,13 @@ describe.each([ const id2 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: id1, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); await broker.enqueueProvingJob({ id: id2, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(2), inputsUri: makeInputsUri(), }); @@ -868,13 +891,13 @@ describe.each([ const id2 = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id: id1, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); await broker.enqueueProvingJob({ id: id2, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(2), inputsUri: makeInputsUri(), }); @@ -906,14 +929,14 @@ describe.each([ const provingJob1: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; const provingJob2: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -956,7 +979,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -970,7 +993,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -988,7 +1011,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1010,7 +1033,7 @@ describe.each([ // epoch has advanced await broker.enqueueProvingJob({ id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(10), inputsUri: makeInputsUri(), }); @@ -1024,7 +1047,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1048,7 +1071,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1059,7 +1082,7 @@ describe.each([ // Advance the epoch height so epoch 1 becomes stale (oldestEpochToKeep = 3 - 1 = 2) await broker.enqueueProvingJob({ id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(3), inputsUri: makeInputsUri(), }); @@ -1076,7 +1099,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1114,7 +1137,7 @@ describe.each([ it('retries jobs', async () => { const provingJob: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -1133,7 +1156,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1155,7 +1178,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1173,7 +1196,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1192,7 +1215,7 @@ describe.each([ // advance the epoch height await broker.enqueueProvingJob({ id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(3), inputsUri: makeInputsUri(), }); @@ -1220,7 +1243,7 @@ describe.each([ await database.addProvingJob({ id: id1, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1238,10 +1261,10 @@ describe.each([ await expect(broker.getProvingJobStatus(id1)).resolves.toEqual({ status: 'in-queue' }); await expect(broker.getProvingJobStatus(id2)).resolves.toEqual({ status: 'in-queue' }); - await expect(broker.getProvingJob({ allowList: [ProvingRequestType.PARITY_BASE] })).resolves.toEqual({ + await expect(broker.getProvingJob({ allowList: [ProvingRequestType.INBOX_PARITY] })).resolves.toEqual({ job: { id: id1, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: expect.any(String), }, @@ -1271,7 +1294,7 @@ describe.each([ await database.addProvingJob({ id: id1, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1305,7 +1328,7 @@ describe.each([ await database.addProvingJob({ id: id1, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1330,7 +1353,7 @@ describe.each([ await broker.start(); const job: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -1349,7 +1372,7 @@ describe.each([ await expect( broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }), @@ -1362,7 +1385,7 @@ describe.each([ const job: ProvingJob = { id: makeRandomProvingJobId(), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }; @@ -1381,7 +1404,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1397,7 +1420,7 @@ describe.each([ await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1414,7 +1437,7 @@ describe.each([ const id = makeRandomProvingJobId(); await broker.enqueueProvingJob({ id, - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, epochNumber: EpochNumber(1), inputsUri: makeInputsUri(), }); @@ -1461,7 +1484,7 @@ describe.each([ await broker.enqueueProvingJob({ id: id1, epochNumber: EpochNumber(1), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: '' as ProofUri, }); await broker.reportProvingJobSuccess(id1, '' as ProofUri); @@ -1470,7 +1493,7 @@ describe.each([ await broker.enqueueProvingJob({ id: id2, epochNumber: EpochNumber(2), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: '' as ProofUri, }); await broker.reportProvingJobSuccess(id2, '' as ProofUri); @@ -1484,7 +1507,7 @@ describe.each([ await broker.enqueueProvingJob({ id: id3, epochNumber: EpochNumber(3), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: '' as ProofUri, }); @@ -1498,7 +1521,7 @@ describe.each([ await broker.enqueueProvingJob({ id: id4, epochNumber: EpochNumber(4), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: '' as ProofUri, }); @@ -1513,7 +1536,7 @@ describe.each([ await broker.enqueueProvingJob({ id: id5, epochNumber: EpochNumber(5), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: '' as ProofUri, }); diff --git a/yarn-project/prover-client/src/proving_broker/proving_broker.ts b/yarn-project/prover-client/src/proving_broker/proving_broker.ts index d1ab4342cf8c..c15a0da446c0 100644 --- a/yarn-project/prover-client/src/proving_broker/proving_broker.ts +++ b/yarn-project/prover-client/src/proving_broker/proving_broker.ts @@ -55,6 +55,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr [ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP]: new PriorityMemoryQueue( provingJobComparator, ), + [ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP]: new PriorityMemoryQueue(provingJobComparator), [ProvingRequestType.BLOCK_ROOT_ROLLUP]: new PriorityMemoryQueue(provingJobComparator), [ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP]: new PriorityMemoryQueue(provingJobComparator), @@ -65,8 +66,7 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr [ProvingRequestType.CHECKPOINT_MERGE_ROLLUP]: new PriorityMemoryQueue(provingJobComparator), [ProvingRequestType.CHECKPOINT_PADDING_ROLLUP]: new PriorityMemoryQueue(provingJobComparator), - [ProvingRequestType.PARITY_BASE]: new PriorityMemoryQueue(provingJobComparator), - [ProvingRequestType.PARITY_ROOT]: new PriorityMemoryQueue(provingJobComparator), + [ProvingRequestType.INBOX_PARITY]: new PriorityMemoryQueue(provingJobComparator), }; // holds a copy of the database in memory in order to quickly fulfill requests @@ -410,9 +410,16 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr : Object.values(ProvingRequestType).filter((x): x is ProvingRequestType => typeof x === 'number'); allowedProofs.sort(proofTypeComparator); + // Select the oldest-epoch job across the allowed queues, tie-breaking by proof-type priority: an epoch's + // remaining jobs always outrank younger epochs' work, so the oldest epoch completes instead of starving + // behind the continuous arrival of new higher-priority-type jobs. The legacy L1-to-L2 tree got this ordering + // for free (block roots waited on parity outputs); the streaming inbox parity only gates the checkpoint + // root, so a purely type-major order would leave it unscheduled under sustained block production. + let selected: { proofType: ProvingRequestType; enqueuedJob: EnqueuedProvingJob; job: ProvingJob } | undefined; for (const proofType of allowedProofs) { const queue = this.queues[proofType]; let enqueuedJob: EnqueuedProvingJob | undefined; + let candidate: { enqueuedJob: EnqueuedProvingJob; job: ProvingJob } | undefined; // exhaust the queue and make sure we're not sending a job that's already in progress // or has already been completed // this can happen if the broker crashes and restarts @@ -420,25 +427,42 @@ export class ProvingBroker implements ProvingJobProducer, ProvingJobConsumer, Pr while ((enqueuedJob = queue.getImmediate())) { const job = this.jobsCache.get(enqueuedJob.id); if (job && !this.inProgress.has(enqueuedJob.id) && !this.resultsCache.has(enqueuedJob.id)) { - const time = this.msTimeSource(); - this.inProgress.set(job.id, { - id: job.id, - startedAt: time, - lastUpdatedAt: time, - }); - const enqueuedAt = this.enqueuedAt.get(job.id); - if (enqueuedAt) { - this.instrumentation.recordJobWait(job.type, enqueuedAt); - // we can clear this flag now. - this.enqueuedAt.delete(job.id); - } - - return { job, time }; + candidate = { enqueuedJob, job }; + break; } } + if (!candidate) { + continue; + } + if (selected === undefined || candidate.enqueuedJob.epochNumber < selected.enqueuedJob.epochNumber) { + if (selected) { + this.queues[selected.proofType].put(selected.enqueuedJob); + } + selected = { proofType, ...candidate }; + } else { + queue.put(candidate.enqueuedJob); + } + } + + if (!selected) { + return undefined; + } + + const { job } = selected; + const time = this.msTimeSource(); + this.inProgress.set(job.id, { + id: job.id, + startedAt: time, + lastUpdatedAt: time, + }); + const enqueuedAt = this.enqueuedAt.get(job.id); + if (enqueuedAt) { + this.instrumentation.recordJobWait(job.type, enqueuedAt); + // we can clear this flag now. + this.enqueuedAt.delete(job.id); } - return undefined; + return { job, time }; } async #reportProvingJobError( @@ -784,6 +808,7 @@ export const PROOF_TYPES_IN_PRIORITY_ORDER: ProvingRequestType[] = [ ProvingRequestType.BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP, ProvingRequestType.BLOCK_ROOT_ROLLUP, ProvingRequestType.BLOCK_ROOT_SINGLE_TX_ROLLUP, + ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP, ProvingRequestType.BLOCK_MERGE_ROLLUP, ProvingRequestType.CHECKPOINT_ROOT_ROLLUP, ProvingRequestType.CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP, @@ -794,6 +819,5 @@ export const PROOF_TYPES_IN_PRIORITY_ORDER: ProvingRequestType[] = [ ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, ProvingRequestType.PUBLIC_VM, ProvingRequestType.PUBLIC_CHONK_VERIFIER, - ProvingRequestType.PARITY_ROOT, - ProvingRequestType.PARITY_BASE, + ProvingRequestType.INBOX_PARITY, ]; diff --git a/yarn-project/prover-client/src/proving_broker/proving_broker_agent_integration.test.ts b/yarn-project/prover-client/src/proving_broker/proving_broker_agent_integration.test.ts index e52e3791c04c..f023de614806 100644 --- a/yarn-project/prover-client/src/proving_broker/proving_broker_agent_integration.test.ts +++ b/yarn-project/prover-client/src/proving_broker/proving_broker_agent_integration.test.ts @@ -6,7 +6,7 @@ import { promiseWithResolvers } from '@aztec/foundation/promise'; import { sleep } from '@aztec/foundation/sleep'; import { ProvingJob, makeProvingJobId } from '@aztec/stdlib/interfaces/server'; import { ProvingRequestType } from '@aztec/stdlib/proofs'; -import { makeParityBasePrivateInputs, makeParityPublicInputs } from '@aztec/stdlib/testing'; +import { makeInboxParityPrivateInputs, makeParityPublicInputs } from '@aztec/stdlib/testing'; import { jest } from '@jest/globals'; @@ -63,9 +63,9 @@ describe('ProvingBroker <-> ProvingAgent integration', () => { const duplicateJobs: string[] = []; - jest.spyOn(prover, 'getBaseParityProof').mockImplementation((inputs, signal) => { + jest.spyOn(prover, 'getInboxParityProof').mockImplementation((inputs, signal) => { const inputsHash = sha256(inputs.toBuffer()); - const id = makeProvingJobId(EpochNumber(0), ProvingRequestType.PARITY_BASE, inputsHash.toString('hex')); + const id = makeProvingJobId(EpochNumber(0), ProvingRequestType.INBOX_PARITY, inputsHash.toString('hex')); // job was given to two agents if (deferreds[id]) { duplicateJobs.push(id); @@ -78,17 +78,17 @@ describe('ProvingBroker <-> ProvingAgent integration', () => { const enqueueRandomJob = async () => { while (true) { - const inputs = makeParityBasePrivateInputs(randomInt(Number.MAX_SAFE_INTEGER)); + const inputs = makeInboxParityPrivateInputs(randomInt(Number.MAX_SAFE_INTEGER)); const inputsHash = sha256(inputs.toBuffer()); - const id = makeProvingJobId(EpochNumber(0), ProvingRequestType.PARITY_BASE, inputsHash.toString('hex')); + const id = makeProvingJobId(EpochNumber(0), ProvingRequestType.INBOX_PARITY, inputsHash.toString('hex')); if (jobs[id]) { continue; } jobs[id] = { id, - type: ProvingRequestType.PARITY_BASE, - inputsUri: await store.saveProofInput(id, ProvingRequestType.PARITY_BASE, inputs), + type: ProvingRequestType.INBOX_PARITY, + inputsUri: await store.saveProofInput(id, ProvingRequestType.INBOX_PARITY, inputs), epochNumber: EpochNumber(0), }; await broker.enqueueProvingJob(jobs[id]); diff --git a/yarn-project/prover-client/src/proving_broker/proving_broker_agent_rpc_integration.test.ts b/yarn-project/prover-client/src/proving_broker/proving_broker_agent_rpc_integration.test.ts index e71eebaf0f8b..d8b2a9ae4600 100644 --- a/yarn-project/prover-client/src/proving_broker/proving_broker_agent_rpc_integration.test.ts +++ b/yarn-project/prover-client/src/proving_broker/proving_broker_agent_rpc_integration.test.ts @@ -38,14 +38,14 @@ describe('ProvingBroker RPC', () => { const inputsUri = isSmall ? makeInputsUri() : (randomBytes(2000).toString('hex') as ProofUri); const job: ProvingJob = { id: makeRandomProvingJobId(EpochNumber(1)), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri, epochNumber: EpochNumber(1), }; await client.enqueueProvingJob(job); - const retrievedJob = await client.getProvingJob({ allowList: [ProvingRequestType.PARITY_BASE] }); + const retrievedJob = await client.getProvingJob({ allowList: [ProvingRequestType.INBOX_PARITY] }); expect(retrievedJob?.job.id).toBe(job.id); expect(retrievedJob?.job.inputsUri).toBe(inputsUri); } finally { diff --git a/yarn-project/prover-client/src/proving_broker/proving_broker_database/broker_persisted_database.test.ts b/yarn-project/prover-client/src/proving_broker/proving_broker_database/broker_persisted_database.test.ts index 3cd951fcc6db..8f7f4b871383 100644 --- a/yarn-project/prover-client/src/proving_broker/proving_broker_database/broker_persisted_database.test.ts +++ b/yarn-project/prover-client/src/proving_broker/proving_broker_database/broker_persisted_database.test.ts @@ -52,7 +52,7 @@ describe('ProvingBrokerPersistedDatabase', () => { db.addProvingJob({ id, epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }), ).resolves.not.toThrow(); @@ -66,7 +66,7 @@ describe('ProvingBrokerPersistedDatabase', () => { db.addProvingJob({ id, epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }), ).resolves.not.toThrow(); @@ -79,7 +79,7 @@ describe('ProvingBrokerPersistedDatabase', () => { await db.addProvingJob({ id, epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); await expect(db.setProvingJobResult(id, 'Proof' as ProofUri)).resolves.not.toThrow(); @@ -91,7 +91,7 @@ describe('ProvingBrokerPersistedDatabase', () => { await db.addProvingJob({ id, epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); @@ -108,7 +108,7 @@ describe('ProvingBrokerPersistedDatabase', () => { await db.addProvingJob({ id, epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); @@ -121,7 +121,7 @@ describe('ProvingBrokerPersistedDatabase', () => { await db.addProvingJob({ id, epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); @@ -137,7 +137,7 @@ describe('ProvingBrokerPersistedDatabase', () => { const job: ProvingJob = { id, epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }; await db.addProvingJob(job); @@ -163,7 +163,7 @@ describe('ProvingBrokerPersistedDatabase', () => { db.addProvingJob({ id, epochNumber: EpochNumber(startEpoch + i), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }), ).resolves.not.toThrow(); @@ -181,7 +181,7 @@ describe('ProvingBrokerPersistedDatabase', () => { const job: ProvingJob = { id, epochNumber: EpochNumber(startEpoch + i), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }; await db.addProvingJob(job); @@ -211,7 +211,7 @@ describe('ProvingBrokerPersistedDatabase', () => { await db.addProvingJob({ id, epochNumber: EpochNumber(startEpoch + i), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }); epochs.push(startEpoch + i); @@ -228,7 +228,7 @@ describe('ProvingBrokerPersistedDatabase', () => { const job: ProvingJob = { id, epochNumber: EpochNumber(startEpoch + i), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }; await db.addProvingJob(job); @@ -273,7 +273,7 @@ describe('ProvingBrokerPersistedDatabase', () => { const job: ProvingJob = { id, epochNumber: EpochNumber(startEpoch + i), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }; await db.addProvingJob(job); @@ -313,7 +313,7 @@ describe('ProvingBrokerPersistedDatabase', () => { const job: ProvingJob = { id, epochNumber: EpochNumber(startEpoch + i), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }; await db.addProvingJob(job); @@ -378,7 +378,7 @@ describe('ProvingBrokerPersistedDatabase', () => { db.addProvingJob({ id, epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }), ); @@ -405,7 +405,7 @@ describe('ProvingBrokerPersistedDatabase', () => { db.addProvingJob({ id: makeRandomProvingJobId(EpochNumber(42)), epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }), ); @@ -413,7 +413,7 @@ describe('ProvingBrokerPersistedDatabase', () => { db.addProvingJob({ id: makeRandomProvingJobId(EpochNumber(42)), epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }), ); @@ -421,7 +421,7 @@ describe('ProvingBrokerPersistedDatabase', () => { db.addProvingJob({ id: makeRandomProvingJobId(EpochNumber(42)), epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }), ); @@ -439,7 +439,7 @@ describe('ProvingBrokerPersistedDatabase', () => { db.addProvingJob({ id: makeRandomProvingJobId(EpochNumber(42)), epochNumber: EpochNumber(42), - type: ProvingRequestType.PARITY_BASE, + type: ProvingRequestType.INBOX_PARITY, inputsUri: makeInputsUri(), }), ); diff --git a/yarn-project/prover-client/src/proving_broker/proving_broker_database/persisted.ts b/yarn-project/prover-client/src/proving_broker/proving_broker_database/persisted.ts index 3dd2686583ed..36d764c6ce44 100644 --- a/yarn-project/prover-client/src/proving_broker/proving_broker_database/persisted.ts +++ b/yarn-project/prover-client/src/proving_broker/proving_broker_database/persisted.ts @@ -27,7 +27,7 @@ import type { ProverBrokerConfig } from '../config.js'; import type { ProvingBrokerDatabase } from '../proving_broker_database.js'; class SingleEpochDatabase { - public static readonly SCHEMA_VERSION = 1; + public static readonly SCHEMA_VERSION = 2; private jobs: AztecAsyncMap; private jobResults: AztecAsyncMap; diff --git a/yarn-project/prover-client/src/proving_broker/proving_job_controller.test.ts b/yarn-project/prover-client/src/proving_broker/proving_job_controller.test.ts index 3b48fe70226f..a4e4d944b35d 100644 --- a/yarn-project/prover-client/src/proving_broker/proving_job_controller.test.ts +++ b/yarn-project/prover-client/src/proving_broker/proving_job_controller.test.ts @@ -5,7 +5,7 @@ import { promiseWithResolvers } from '@aztec/foundation/promise'; import { sleep } from '@aztec/foundation/sleep'; import { type ProvingJobId, makePublicInputsAndRecursiveProof } from '@aztec/stdlib/interfaces/server'; import { ProvingRequestType, makeRecursiveProof } from '@aztec/stdlib/proofs'; -import { makeParityBasePrivateInputs, makeParityPublicInputs } from '@aztec/stdlib/testing'; +import { makeInboxParityPrivateInputs, makeParityPublicInputs } from '@aztec/stdlib/testing'; import { VerificationKeyData } from '@aztec/stdlib/vks'; import { jest } from '@jest/globals'; @@ -24,8 +24,8 @@ describe('ProvingJobController', () => { controller = new ProvingJobController( '1' as ProvingJobId, { - type: ProvingRequestType.PARITY_BASE, - inputs: makeParityBasePrivateInputs(), + type: ProvingRequestType.INBOX_PARITY, + inputs: makeInboxParityPrivateInputs(), }, EpochNumber(0), 42, @@ -63,7 +63,7 @@ describe('ProvingJobController', () => { makeRecursiveProof(RECURSIVE_PROOF_LENGTH), VerificationKeyData.makeFakeHonk(), ); - jest.spyOn(prover, 'getBaseParityProof').mockResolvedValueOnce(resp); + jest.spyOn(prover, 'getInboxParityProof').mockResolvedValueOnce(resp); controller.start(); await sleep(1); // give promises a chance to complete @@ -73,7 +73,7 @@ describe('ProvingJobController', () => { it('calls onComplete with the error', async () => { const err = new Error('test error'); - jest.spyOn(prover, 'getBaseParityProof').mockRejectedValueOnce(err); + jest.spyOn(prover, 'getInboxParityProof').mockRejectedValueOnce(err); controller.start(); await sleep(1); @@ -95,7 +95,7 @@ describe('ProvingJobController', () => { it('calls onComplete if abort is called but result is masked', async () => { const { promise, resolve } = promiseWithResolvers(); - jest.spyOn(prover, 'getBaseParityProof').mockReturnValueOnce(promise); + jest.spyOn(prover, 'getInboxParityProof').mockReturnValueOnce(promise); controller.start(); diff --git a/yarn-project/prover-client/src/proving_broker/proving_job_controller.ts b/yarn-project/prover-client/src/proving_broker/proving_job_controller.ts index 043d0293eef5..74f3e41bfa43 100644 --- a/yarn-project/prover-client/src/proving_broker/proving_job_controller.ts +++ b/yarn-project/prover-client/src/proving_broker/proving_job_controller.ts @@ -162,6 +162,10 @@ export class ProvingJobController { return await this.circuitProver.getBlockRootEmptyTxFirstRollupProof(inputs, signal, this.epochNumber); } + case ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP: { + return await this.circuitProver.getBlockRootMsgsOnlyRollupProof(inputs, signal, this.epochNumber); + } + case ProvingRequestType.BLOCK_ROOT_ROLLUP: { return await this.circuitProver.getBlockRootRollupProof(inputs, signal, this.epochNumber); } @@ -194,12 +198,8 @@ export class ProvingJobController { return await this.circuitProver.getRootRollupProof(inputs, signal, this.epochNumber); } - case ProvingRequestType.PARITY_BASE: { - return await this.circuitProver.getBaseParityProof(inputs, signal, this.epochNumber); - } - - case ProvingRequestType.PARITY_ROOT: { - return await this.circuitProver.getRootParityProof(inputs, signal, this.epochNumber); + case ProvingRequestType.INBOX_PARITY: { + return await this.circuitProver.getInboxParityProof(inputs, signal, this.epochNumber); } default: { diff --git a/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts b/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts index db00fb35bbfb..4dd1b8136718 100644 --- a/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts +++ b/yarn-project/prover-client/src/test/bb_prover_full_rollup.test.ts @@ -3,6 +3,7 @@ import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, PAIRING_POINTS_SIZE } from '@aztec import { EpochNumber } from '@aztec/foundation/branded-types'; import { timesAsync } from '@aztec/foundation/collection'; import { parseBooleanEnv } from '@aztec/foundation/config'; +import { Fr } from '@aztec/foundation/curves/bn254'; import { EthAddress } from '@aztec/foundation/eth-address'; import { type Logger, createLogger } from '@aztec/foundation/log'; import { getTestData, isGenerateTestDataEnabled } from '@aztec/foundation/testing'; @@ -67,6 +68,9 @@ describe('prover/bb_prover/full-rollup', () => { for (let checkpointIndex = 0; checkpointIndex < numCheckpoints; checkpointIndex++) { const { constants, blocks, l1ToL2Messages, previousBlockHeader, checkpoint } = checkpoints[checkpointIndex]; + const previousInboxRollingHash = + checkpointIndex === 0 ? Fr.ZERO : checkpoints[checkpointIndex - 1].checkpoint.header.inboxRollingHash; + log.info(`Starting new checkpoint #${checkpointIndex}`); const subTree = await CheckpointSubTreeOrchestrator.start( context.worldState, @@ -78,6 +82,7 @@ describe('prover/bb_prover/full-rollup', () => { makeTestDeferredJobQueue(), constants, l1ToL2Messages, + previousInboxRollingHash, numBlockPerCheckpoint, previousBlockHeader, ); @@ -98,7 +103,9 @@ describe('prover/bb_prover/full-rollup', () => { } topTreeData.push({ - blockProofs: subTree.getSubTreeResult().then(r => r.blockProofOutputs), + subTreeProofs: subTree + .getSubTreeResult() + .then(r => ({ blockProofOutputs: r.blockProofOutputs, inboxParityProof: r.inboxParityProof })), l2ToL1MsgsPerBlock: blocks.map(b => b.txs.map(tx => tx.txEffect.l2ToL1Msgs)), blobFields: checkpoint.toBlobFields(), previousBlockHeader, diff --git a/yarn-project/prover-client/src/test/bb_prover_parity.test.ts b/yarn-project/prover-client/src/test/bb_prover_parity.test.ts index 64e98703a317..fbb920407ead 100644 --- a/yarn-project/prover-client/src/test/bb_prover_parity.test.ts +++ b/yarn-project/prover-client/src/test/bb_prover_parity.test.ts @@ -1,26 +1,24 @@ import { BBNativeRollupProver, type BBProverConfig } from '@aztec/bb-prover'; -import { - NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, - NUM_BASE_PARITY_PER_ROOT_PARITY, - PARITY_BASE_VK_INDEX, - RECURSIVE_PROOF_LENGTH, -} from '@aztec/constants'; -import { makeTuple } from '@aztec/foundation/array'; import { parseBooleanEnv } from '@aztec/foundation/config'; -import { randomBytes } from '@aztec/foundation/crypto/random'; import { Fr } from '@aztec/foundation/curves/bn254'; import { createLogger } from '@aztec/foundation/log'; +import type { ServerProtocolArtifact } from '@aztec/noir-protocol-circuits-types/server'; import { ServerCircuitVks } from '@aztec/noir-protocol-circuits-types/server/vks'; import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree'; -import { ParityBasePrivateInputs, ParityPublicInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity'; -import { makeRecursiveProof } from '@aztec/stdlib/proofs'; -import { VerificationKeyData } from '@aztec/stdlib/vks'; +import { L1ToL2MessageSponge, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging'; +import { INBOX_PARITY_SIZES, InboxParityPrivateInputs, type InboxParitySize } from '@aztec/stdlib/parity'; import { TestContext } from '../mocks/test_context.js'; -import { toProofData } from '../orchestrator/block-building-helpers.js'; const logger = createLogger('prover-client:test:bb-prover-parity'); +// Maps a ladder size to its server artifact name, mirroring the bb-prover's own selection. +const artifactForSize: Record = { + 64: 'InboxParity64Artifact', + 256: 'InboxParity256Artifact', + 1024: 'InboxParity1024Artifact', +}; + describe('prover/bb_prover/parity', () => { const FAKE_PROOFS = parseBooleanEnv(process.env.FAKE_PROOFS); @@ -29,7 +27,7 @@ describe('prover/bb_prover/parity', () => { beforeAll(async () => { const buildProver = async (bbConfig: BBProverConfig) => { - bbConfig.circuitFilter = ['ParityBaseArtifact', 'ParityRootArtifact']; + bbConfig.circuitFilter = Object.values(artifactForSize); bbProver = await BBNativeRollupProver.new(bbConfig); return bbProver; }; @@ -43,118 +41,35 @@ describe('prover/bb_prover/parity', () => { await context.cleanup(); }); - it( - 'proves the parity circuits', - async () => { - const l1ToL2Messages = new Array(NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP).fill(null).map(() => Fr.random()); + // One InboxParity proof per checkpoint, sized to the smallest ladder rung that fits. Prove and verify each rung. + it.each(INBOX_PARITY_SIZES)( + 'proves and verifies the inbox parity circuit at size %i', + async size => { + // Fill the rung with real messages so `numMessages === size` (the largest circuit for that rung). + const messages = Array.from({ length: size }, () => Fr.random()); const proverId = Fr.random(); - const baseParityInputs = makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, i => - ParityBasePrivateInputs.fromSlice(l1ToL2Messages, i, getVKTreeRoot(), proverId), - ); - - // Generate the base parity proofs - const baseParityProofsAndPublicInputs = await Promise.all( - baseParityInputs.map(baseInputs => context.prover.getBaseParityProof(baseInputs)), + // The in_hash is a sha256 frontier root (top byte zeroed to fit the field), which `ParityPublicInputs` enforces; + // compute it from the messages rather than using a raw random field. + const inHash = computeInHashFromL1ToL2Messages(messages); + + const inputs = InboxParityPrivateInputs.fromMessages( + messages, + Fr.ZERO, + L1ToL2MessageSponge.empty(), + inHash, + getVKTreeRoot(), + proverId, ); + expect(inputs.size).toBe(size); - const rootInputs = makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, i => { - const inputs = baseParityProofsAndPublicInputs[i]; - return toProofData(inputs); - }); + const output = await context.prover.getInboxParityProof(inputs); - // These could differ if artifacts generated by `generate_vk_json.js` are not consistent with what we do, - // which would cause the root parity proof to fail, because the proof of VK root inclusion would not match the key in the proof. - expect(ServerCircuitVks.ParityBaseArtifact.keyAsFields.hash).toEqual(rootInputs[0].vkData.vk.keyAsFields.hash); + const artifact = artifactForSize[size as InboxParitySize]; + // Sanity: the VK the proof was generated against is the one in the vk tree for this rung. + expect(ServerCircuitVks[artifact].keyAsFields.hash).toEqual(output.verificationKey.keyAsFields.hash); - // Verify the base parity proofs if (bbProver) { - await expect( - Promise.all( - baseParityProofsAndPublicInputs.map(input => - bbProver!.verifyProof('ParityBaseArtifact', input.proof.binaryProof), - ), - ), - ).resolves.not.toThrow(); - } - - // Now generate the root parity proof - const rootParityInputs = new ParityRootPrivateInputs(rootInputs); - const rootOutput = await context.prover.getRootParityProof(rootParityInputs); - - // We only test validity and negative proofs with actual proofs enabled - if (!bbProver) { - return; - } - - // Verify the root parity proof - await expect(bbProver.verifyProof('ParityRootArtifact', rootOutput.proof.binaryProof)).resolves.not.toThrow(); - - // Now test for negative cases. We will try and generate 3 invalid proofs. - // One where a single child has an invalid proof - // One where a child has incorrect public inputs - // One where a child has an invalid verification key - // In each case either the proof should fail to generate or verify - - const validVk = rootParityInputs.children[0].vkData.vk; - const validPublicInputs = rootParityInputs.children[0].publicInputs; - const validProof = rootParityInputs.children[0].proof; - - const defectiveProofInput = toProofData({ - inputs: validPublicInputs, - proof: makeRecursiveProof(RECURSIVE_PROOF_LENGTH, 0x500), - verificationKey: validVk, - }); - - const shaRoot = randomBytes(32); - shaRoot[0] = 0; - - const defectivePublicInputs = toProofData({ - inputs: new ParityPublicInputs(Fr.fromBuffer(shaRoot), Fr.random(), getVKTreeRoot(), proverId), - proof: validProof, - verificationKey: validVk, - }); - - const defectiveVerificationKey = toProofData( - { - inputs: validPublicInputs, - proof: validProof, - verificationKey: VerificationKeyData.makeFakeHonk(), - }, - PARITY_BASE_VK_INDEX, - ); - - const tupleWithDefectiveProof = makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, (i: number) => { - if (i == 0) { - return defectiveProofInput; - } - return rootParityInputs.children[i]; - }); - - const tupleWithDefectiveInputs = makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, (i: number) => { - if (i == 0) { - return defectivePublicInputs; - } - return rootParityInputs.children[i]; - }); - - const tupleWithDefectiveVK = makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, (i: number) => { - if (i == 0) { - return defectiveVerificationKey; - } - return rootParityInputs.children[i]; - }); - - // Check the invalid VK scenario with an invalid witness assertion - await expect( - context.prover.getRootParityProof(new ParityRootPrivateInputs(tupleWithDefectiveVK)), - ).rejects.toThrow('Failed to generate witness'); - - for (const t of [tupleWithDefectiveProof, tupleWithDefectiveInputs]) { - await expect(async () => { - const result = await context.prover.getRootParityProof(new ParityRootPrivateInputs(t)); - await bbProver!.verifyProof('ParityRootArtifact', result.proof.binaryProof); - fail('Proof should not be generated and verified'); - }).rejects.toThrow(/Failed to generate proof|Failed to verify proof/); + await expect(bbProver.verifyProof(artifact, output.proof.binaryProof)).resolves.not.toThrow(); } }, FAKE_PROOFS ? undefined : 600_000, diff --git a/yarn-project/prover-client/src/test/epoch_proving_sim.test.ts b/yarn-project/prover-client/src/test/epoch_proving_sim.test.ts index a83b8ced6935..2954b2e5fa3b 100644 --- a/yarn-project/prover-client/src/test/epoch_proving_sim.test.ts +++ b/yarn-project/prover-client/src/test/epoch_proving_sim.test.ts @@ -1,5 +1,4 @@ import { PROOF_DELAY_MS, WITGEN_DELAY_MS } from '@aztec/bb-prover/test'; -import { NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants'; import { insertIntoSortedArray } from '@aztec/foundation/array'; import { times } from '@aztec/foundation/collection'; import { ProvingRequestType } from '@aztec/stdlib/proofs'; @@ -25,8 +24,7 @@ const PROOF_TYPES_IN_PRIORITY_ORDER: ProvingRequestType[] = [ ProvingRequestType.PRIVATE_TX_BASE_ROLLUP, ProvingRequestType.PUBLIC_VM, ProvingRequestType.PUBLIC_CHONK_VERIFIER, - ProvingRequestType.PARITY_ROOT, - ProvingRequestType.PARITY_BASE, // Lowest priority + ProvingRequestType.INBOX_PARITY, // Lowest priority ]; // Job represents a proving task with its hierarchical context @@ -66,9 +64,8 @@ type TestConfig = { // State tracking for dependency resolution type SimState = { - // Parity tracking (per checkpoint, first block only) - baseParityComplete: Map; - rootParityComplete: Map; + // Parity tracking: one InboxParity proof per checkpoint, gating the first block root. + inboxParityComplete: Map; // Public tx dependency tracking (aggregate per block) // Key format: "checkpoint-block" @@ -243,8 +240,7 @@ function getBlockTxCount(block: Block): { privateTxs: number; publicTxs: number; function initializeState(checkpoints: Checkpoint[]): SimState { const state: SimState = { - baseParityComplete: new Map(), - rootParityComplete: new Map(), + inboxParityComplete: new Map(), vmComplete: new Map(), chonkComplete: new Map(), publicBaseEnqueued: new Map(), @@ -267,8 +263,7 @@ function initializeState(checkpoints: Checkpoint[]): SimState { for (let cp = 1; cp <= checkpoints.length; cp++) { const blocks = checkpoints[cp - 1]; state.blocksPerCheckpoint.set(cp, blocks.length); - state.baseParityComplete.set(cp, 0); - state.rootParityComplete.set(cp, false); + state.inboxParityComplete.set(cp, false); state.blockRootComplete.set(cp, false); state.checkpointRootComplete.set(cp, false); @@ -300,10 +295,8 @@ function fillQueue(queues: Queues, checkpoints: Checkpoint[]): void { for (let cp = 1; cp <= checkpoints.length; cp++) { const blocks = checkpoints[cp - 1]; - // assume every checkpoint includes cross-chain messages - queues[ProvingRequestType.PARITY_BASE].push( - ...times(NUM_BASE_PARITY_PER_ROOT_PARITY, () => createJob(cp, 1, ProvingRequestType.PARITY_BASE)), - ); + // assume every checkpoint includes cross-chain messages: one InboxParity proof per checkpoint + queues[ProvingRequestType.INBOX_PARITY].push(createJob(cp, 1, ProvingRequestType.INBOX_PARITY)); for (let b = 1; b <= blocks.length; b++) { const block = blocks[b - 1]; @@ -335,18 +328,8 @@ function enqueueDependentJobs(job: Job, state: SimState, queues: Queues, checkpo const key = blockKey(checkpoint, block); switch (type) { - case ProvingRequestType.PARITY_BASE: { - const count = (state.baseParityComplete.get(checkpoint) ?? 0) + 1; - state.baseParityComplete.set(checkpoint, count); - - if (count === NUM_BASE_PARITY_PER_ROOT_PARITY) { - queues[ProvingRequestType.PARITY_ROOT].push(createJob(checkpoint, 1, ProvingRequestType.PARITY_ROOT)); - } - break; - } - - case ProvingRequestType.PARITY_ROOT: { - state.rootParityComplete.set(checkpoint, true); + case ProvingRequestType.INBOX_PARITY: { + state.inboxParityComplete.set(checkpoint, true); tryEnqueueBlockRoot(checkpoint, 1, state, queues); break; } @@ -523,8 +506,8 @@ function tryEnqueueBlockRoot(checkpoint: number, blk: number, state: SimState, q return; } - // First block also needs root parity - if (isFirst && !state.rootParityComplete.get(checkpoint)) { + // First block also needs the checkpoint's InboxParity proof + if (isFirst && !state.inboxParityComplete.get(checkpoint)) { return; } diff --git a/yarn-project/prover-client/src/test/mock_prover.ts b/yarn-project/prover-client/src/test/mock_prover.ts index 51415ebf677e..59b9d4c5a7c1 100644 --- a/yarn-project/prover-client/src/test/mock_prover.ts +++ b/yarn-project/prover-client/src/test/mock_prover.ts @@ -1,6 +1,5 @@ import { AVM_V2_PROOF_LENGTH_IN_FIELDS, - NESTED_RECURSIVE_PROOF_LENGTH, NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, RECURSIVE_PROOF_LENGTH, } from '@aztec/constants'; @@ -15,13 +14,14 @@ import { type ServerCircuitProver, makePublicInputsAndRecursiveProof, } from '@aztec/stdlib/interfaces/server'; -import type { ParityBasePrivateInputs, ParityRootPrivateInputs } from '@aztec/stdlib/parity'; +import type { InboxParityPrivateInputs } from '@aztec/stdlib/parity'; import { makeEmptyRecursiveProof, makeRecursiveProof } from '@aztec/stdlib/proofs'; import type { BlockMergeRollupPrivateInputs, BlockRollupPublicInputs, BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, + BlockRootMsgsOnlyRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, @@ -107,7 +107,7 @@ export class MockProver implements ServerCircuitProver { return Promise.resolve(makeEmptyRecursiveProof(AVM_V2_PROOF_LENGTH_IN_FIELDS)); } - getBaseParityProof(_inputs: ParityBasePrivateInputs, _signal?: AbortSignal, _epochNumber?: number) { + getInboxParityProof(_inputs: InboxParityPrivateInputs, _signal?: AbortSignal, _epochNumber?: number) { return Promise.resolve( makePublicInputsAndRecursiveProof( makeParityPublicInputs(), @@ -117,16 +117,6 @@ export class MockProver implements ServerCircuitProver { ); } - getRootParityProof(_inputs: ParityRootPrivateInputs, _signal?: AbortSignal, _epochNumber?: number) { - return Promise.resolve( - makePublicInputsAndRecursiveProof( - makeParityPublicInputs(), - makeRecursiveProof(NESTED_RECURSIVE_PROOF_LENGTH), - VerificationKeyData.makeFakeHonk(), - ), - ); - } - getPublicChonkVerifierProof( _inputs: PublicChonkVerifierPrivateInputs, _signal?: AbortSignal, @@ -227,6 +217,20 @@ export class MockProver implements ServerCircuitProver { ); } + getBlockRootMsgsOnlyRollupProof( + _input: BlockRootMsgsOnlyRollupPrivateInputs, + _signal?: AbortSignal, + _epochNumber?: number, + ): Promise> { + return Promise.resolve( + makePublicInputsAndRecursiveProof( + makeBlockRollupPublicInputs(), + makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), + VerificationKeyData.makeFakeRollupHonk(), + ), + ); + } + getBlockRootRollupProof( _input: BlockRootRollupPrivateInputs, _signal?: AbortSignal, diff --git a/yarn-project/prover-client/src/test/proving_broker_testbench.test.ts b/yarn-project/prover-client/src/test/proving_broker_testbench.test.ts index 67bff56cdb43..d50aac8f3ef2 100644 --- a/yarn-project/prover-client/src/test/proving_broker_testbench.test.ts +++ b/yarn-project/prover-client/src/test/proving_broker_testbench.test.ts @@ -164,8 +164,7 @@ function getProofCounts( counts[priorityIndex(ProvingRequestType.CHECKPOINT_ROOT_ROLLUP)] = numCheckpoints; } - counts[priorityIndex(ProvingRequestType.PARITY_BASE)] = numCheckpoints * 4; - counts[priorityIndex(ProvingRequestType.PARITY_ROOT)] = numCheckpoints; + counts[priorityIndex(ProvingRequestType.INBOX_PARITY)] = numCheckpoints; if (numBlocksPerCheckpoint > 2) { counts[priorityIndex(ProvingRequestType.BLOCK_MERGE_ROLLUP)] = (numBlocksPerCheckpoint - 2) * numCheckpoints; diff --git a/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts b/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts new file mode 100644 index 000000000000..00c7bedcd228 --- /dev/null +++ b/yarn-project/prover-client/src/test/regenerate_rollup_sample_inputs.test.ts @@ -0,0 +1,188 @@ +import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP } from '@aztec/constants'; +import { EpochNumber } from '@aztec/foundation/branded-types'; +import { timesAsync } from '@aztec/foundation/collection'; +import { Fr } from '@aztec/foundation/curves/bn254'; +import { EthAddress } from '@aztec/foundation/eth-address'; +import { type Logger, createLogger } from '@aztec/foundation/log'; +import { getTestData, isGenerateTestDataEnabled } from '@aztec/foundation/testing'; +import { updateProtocolCircuitSampleInputs } from '@aztec/foundation/testing/files'; +import type { CircuitName } from '@aztec/stdlib/stats'; + +import TOML from '@iarna/toml'; + +import { TestContext, makeTestDeferredJobQueue } from '../mocks/test_context.js'; +import { CheckpointSubTreeOrchestrator } from '../orchestrator/checkpoint-sub-tree-orchestrator.js'; +import { ChonkCache } from '../orchestrator/chonk-cache.js'; +import { type CheckpointTopTreeData, TopTreeOrchestrator } from '../orchestrator/top-tree-orchestrator.js'; + +// Regenerates the committed `crates/rollup-*/Prover.toml` sample inputs that CI runs `nargo execute` +// against. The rollup circuits push their serialized inputs via `pushTestData` whenever they run +// through the prover, so driving representative epochs through the (simulated) orchestrator and then +// dumping `getTestData(circuitName)` produces fresh, ABI-current fixtures. Run with: +// AZTEC_GENERATE_TEST_DATA=1 yarn workspace @aztec/prover-client test regenerate_rollup_sample_inputs +// Without that flag the whole suite is skipped, so it is a no-op (no prover setup) in normal CI. +// +// The scenarios are chosen to exercise each block-root variant the orchestrator selects (see +// BlockProvingState#getBlockRootRollupTypeAndInputs): a first block with 0 txs, with >=2 txs, and +// with 1 tx; non-first blocks with 1 tx (from the three-block checkpoint) and with >=2 txs (from the +// two-block checkpoint). The three-block checkpoint also produces a block-merge and the three- +// checkpoint epoch a checkpoint-merge; a merge node only exists above the tree root, so both merges +// need three leaves — two would pair directly at the root. Single-block checkpoints feed the +// checkpoint-root-single-block circuit and multi-block checkpoints the (two-input) checkpoint-root +// circuit. Every scenario also produces the root rollup. +const describeOrSkip = isGenerateTestDataEnabled() ? describe : describe.skip; + +describeOrSkip('prover/regenerate-rollup-sample-inputs', () => { + let context: TestContext; + let log: Logger; + + interface Scenario { + numCheckpoints: number; + numBlocksPerCheckpoint: number; + numTxsPerBlock: number; + numL1ToL2Messages: number; + /** Circuits whose sample inputs this scenario is responsible for regenerating. */ + dump: CircuitName[]; + } + + const withMessages = NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP; + + const scenarios: Scenario[] = [ + { + numCheckpoints: 1, + numBlocksPerCheckpoint: 1, + numTxsPerBlock: 0, + numL1ToL2Messages: withMessages, + dump: ['rollup-block-root-first-empty-tx'], + }, + { + numCheckpoints: 1, + numBlocksPerCheckpoint: 1, + numTxsPerBlock: 2, + numL1ToL2Messages: withMessages, + dump: ['rollup-block-root-first', 'rollup-checkpoint-root-single-block', 'rollup-root'], + }, + { + numCheckpoints: 1, + numBlocksPerCheckpoint: 3, + numTxsPerBlock: 1, + numL1ToL2Messages: withMessages, + dump: [ + 'rollup-block-root-first-single-tx', + 'rollup-block-root-single-tx', + 'rollup-block-merge', + 'rollup-checkpoint-root', + ], + }, + { + numCheckpoints: 1, + numBlocksPerCheckpoint: 2, + numTxsPerBlock: 2, + numL1ToL2Messages: withMessages, + dump: ['rollup-block-root'], + }, + // The checkpoint-merge only appears with three checkpoints. Independently-built checkpoints do + // not carry the inbox message state forward, so this scenario runs with no L1-to-L2 messages and + // a zero previous rolling hash, matching the multi-checkpoint case in top-tree-orchestrator.test. + { + numCheckpoints: 3, + numBlocksPerCheckpoint: 1, + numTxsPerBlock: 1, + numL1ToL2Messages: 0, + dump: ['rollup-checkpoint-merge'], + }, + ]; + + beforeEach(async () => { + log = createLogger('prover-client:test:regenerate-rollup-sample-inputs'); + context = await TestContext.new(log, { proverCount: 1 }); + }); + + afterEach(async () => { + await context.cleanup(); + }); + + it.each(scenarios)( + 'regenerates $dump from an epoch with $numCheckpoints checkpoints, $numBlocksPerCheckpoint blocks, $numTxsPerBlock txs', + async ({ numCheckpoints, numBlocksPerCheckpoint, numTxsPerBlock, numL1ToL2Messages, dump }) => { + const checkpoints = await timesAsync(numCheckpoints, () => + context.makeCheckpoint(numBlocksPerCheckpoint, { + numTxsPerBlock, + numL1ToL2Messages, + makeProcessedTxOpts: (_, txIndex) => ({ privateOnly: txIndex % 2 === 0 }), + }), + ); + + const finalBlobChallenges = await context.getFinalBlobChallenges(); + const chonkCache = new ChonkCache(); + const subTrees: CheckpointSubTreeOrchestrator[] = []; + const topTreeData: CheckpointTopTreeData[] = []; + + try { + for (let checkpointIndex = 0; checkpointIndex < numCheckpoints; checkpointIndex++) { + const { constants, blocks, l1ToL2Messages, previousBlockHeader, checkpoint } = checkpoints[checkpointIndex]; + + // First checkpoint starts from genesis; the multi-checkpoint scenario carries no messages, + // so every checkpoint's previous rolling hash is zero. + const previousInboxRollingHash = Fr.ZERO; + + const subTree = await CheckpointSubTreeOrchestrator.start( + context.worldState, + context.prover, + EthAddress.ZERO, + chonkCache, + EpochNumber(1), + /* cancelJobsOnStop */ false, + makeTestDeferredJobQueue(), + constants, + l1ToL2Messages, + previousInboxRollingHash, + numBlocksPerCheckpoint, + previousBlockHeader, + ); + subTrees.push(subTree); + + for (let i = 0; i < numBlocksPerCheckpoint; i++) { + const { header, txs } = blocks[i]; + const { blockNumber, timestamp } = header.globalVariables; + + await subTree.startNewBlock(blockNumber, timestamp, txs.length); + if (txs.length > 0) { + await subTree.addTxs(txs); + } + await subTree.setBlockCompleted(blockNumber, header); + } + + topTreeData.push({ + subTreeProofs: subTree + .getSubTreeResult() + .then(r => ({ blockProofOutputs: r.blockProofOutputs, inboxParityProof: r.inboxParityProof })), + l2ToL1MsgsPerBlock: blocks.map(b => b.txs.map(tx => tx.txEffect.l2ToL1Msgs)), + blobFields: checkpoint.toBlobFields(), + previousBlockHeader, + previousArchiveSiblingPath: subTree.getPreviousArchiveSiblingPath(), + }); + } + + const topTree = new TopTreeOrchestrator(context.prover, EthAddress.ZERO, makeTestDeferredJobQueue()); + try { + await topTree.prove(EpochNumber(1), numCheckpoints, finalBlobChallenges, topTreeData); + } finally { + await topTree.stop(); + } + + for (const circuitName of dump) { + const data = getTestData(circuitName); + if (!data || data.length === 0) { + throw new Error(`No test data captured for ${circuitName}; scenario does not exercise it.`); + } + updateProtocolCircuitSampleInputs(circuitName, TOML.stringify(data[0] as any)); + log.info(`Regenerated sample inputs for ${circuitName}`); + } + } finally { + await Promise.all(subTrees.map(s => s.stop())); + } + }, + 300_000, + ); +}); diff --git a/yarn-project/prover-node/src/actions/rerun-epoch-proving-job.ts b/yarn-project/prover-node/src/actions/rerun-epoch-proving-job.ts index 1a64e5c2ccb4..d909738c118b 100644 --- a/yarn-project/prover-node/src/actions/rerun-epoch-proving-job.ts +++ b/yarn-project/prover-node/src/actions/rerun-epoch-proving-job.ts @@ -6,7 +6,7 @@ import { DateProvider } from '@aztec/foundation/timer'; import { type ProverClientConfig, createProverClient } from '@aztec/prover-client'; import { ProverBrokerConfig, createAndStartProvingBroker } from '@aztec/prover-client/broker'; import { getLastSiblingPath } from '@aztec/prover-client/helpers'; -import { ChonkCache } from '@aztec/prover-client/orchestrator'; +import { type CheckpointSubTreeProofs, ChonkCache } from '@aztec/prover-client/orchestrator'; import { AvmSimulatorPool, PublicProcessorFactory } from '@aztec/simulator/server'; import type { L2Block } from '@aztec/stdlib/block'; import { getEpochAtSlot, getSlotRangeForEpoch } from '@aztec/stdlib/epoch-helpers'; @@ -86,7 +86,7 @@ export async function rerunCheckpointProvingJob( log: Logger, config: RerunConfig, genesis?: GenesisData, -) { +): Promise { await using ctx = await createRerunContext(localPath, log, config, genesis); const { jobData } = ctx; const checkpointNumber = jobData.checkpoints[0].number; @@ -95,9 +95,9 @@ export async function rerunCheckpointProvingJob( const prover = await buildCheckpointProver(ctx, 0, log); try { - const blockProofs = await prover.whenBlockProofsReady(); - log.info(`Completed proving for checkpoint ${checkpointNumber} with ${blockProofs.length} block proof(s)`); - return blockProofs; + const { blockProofOutputs } = await prover.whenSubTreeProofsReady(); + log.info(`Completed proving for checkpoint ${checkpointNumber} with ${blockProofOutputs.length} block proof(s)`); + return blockProofOutputs; } finally { prover.cancel({ routine: true }); await prover.whenDone(); @@ -167,6 +167,8 @@ async function buildCheckpointProver(ctx: RerunContext, index: number, log: Logg const checkpoint = jobData.checkpoints[index]; const previousBlockHeader = index === 0 ? jobData.previousBlockHeader : jobData.checkpoints[index - 1].blocks.at(-1)!.header; + const previousInboxRollingHash = + index === 0 ? jobData.previousInboxRollingHash : jobData.checkpoints[index - 1].header.inboxRollingHash; const l1ToL2Messages = jobData.l1ToL2Messages[checkpoint.number] ?? []; const previousArchiveSiblingPath = await getLastSiblingPath( MerkleTreeId.ARCHIVE, @@ -180,6 +182,7 @@ async function buildCheckpointProver(ctx: RerunContext, index: number, log: Logg attestations, previousBlockHeader, l1ToL2Messages, + previousInboxRollingHash, previousArchiveSiblingPath, }, { diff --git a/yarn-project/prover-node/src/checkpoint-store.test.ts b/yarn-project/prover-node/src/checkpoint-store.test.ts index bd823eb83847..c38a11417358 100644 --- a/yarn-project/prover-node/src/checkpoint-store.test.ts +++ b/yarn-project/prover-node/src/checkpoint-store.test.ts @@ -200,6 +200,7 @@ function makeRegisterData() { attestations: [], previousBlockHeader: {} as any, l1ToL2Messages: [], + previousInboxRollingHash: Fr.ZERO, previousArchiveSiblingPath: makeTuple(ARCHIVE_HEIGHT, () => Fr.ZERO), }; } diff --git a/yarn-project/prover-node/src/job/checkpoint-prover.test.ts b/yarn-project/prover-node/src/job/checkpoint-prover.test.ts index 288a11c3cb71..27e97300cade 100644 --- a/yarn-project/prover-node/src/job/checkpoint-prover.test.ts +++ b/yarn-project/prover-node/src/job/checkpoint-prover.test.ts @@ -134,13 +134,13 @@ describe('CheckpointProver', () => { await prover.whenDone(); }); - it('rejects whenBlockProofsReady() but does not mark the prover failed or fire onFailed', async () => { + it('rejects whenSubTreeProofsReady() but does not mark the prover failed or fire onFailed', async () => { // A cancel (reorg/prune/shutdown) is not a proving failure: isFailed() must stay false and the // onFailed callback must not fire (no post-mortem upload for a cancelled prover). const prover = makeProver(); - const blockProofs = prover.whenBlockProofsReady(); + const subTreeProofs = prover.whenSubTreeProofsReady(); prover.cancel(); - await expect(blockProofs).rejects.toThrow(/cancelled/); + await expect(subTreeProofs).rejects.toThrow(/cancelled/); expect(prover.isFailed()).toBe(false); expect(onFailed).not.toHaveBeenCalled(); await prover.whenDone(); @@ -161,11 +161,11 @@ describe('CheckpointProver', () => { it('routine cancel still aborts and rejects block proofs (only log level differs)', async () => { const prover = makeProver(); - const blockProofs = prover.whenBlockProofsReady(); + const subTreeProofs = prover.whenSubTreeProofsReady(); prover.cancel({ routine: true }); expect(prover.isCancelled()).toBe(true); expect(prover.getAbortSignal().aborted).toBe(true); - await expect(blockProofs).rejects.toThrow(/cancelled/); + await expect(subTreeProofs).rejects.toThrow(/cancelled/); await prover.whenDone(); }); }); @@ -221,7 +221,7 @@ describe('CheckpointProver', () => { // ---------------- gather failure ---------------- describe('gather failures', () => { - it('rejects whenBlockProofsReady when txProvider returns missing txs', async () => { + it('rejects whenSubTreeProofsReady when txProvider returns missing txs', async () => { const missingHash = checkpoint.blocks[0].body.txEffects[0]?.txHash; // Without a real missing hash the per-block payload would be empty and the prover // would happily proceed; only checkpoints with txs can exercise this branch. @@ -232,7 +232,7 @@ describe('CheckpointProver', () => { txProvider.getTxsForBlock.mockResolvedValue({ txs: [], missingTxs: [missingHash] }); const prover = makeProver(); - await expect(prover.whenBlockProofsReady()).rejects.toThrow(/Txs not found/); + await expect(prover.whenSubTreeProofsReady()).rejects.toThrow(/Txs not found/); await prover.whenDone(); }); @@ -245,19 +245,19 @@ describe('CheckpointProver', () => { txProvider.getTxsForBlock.mockReturnValue(gate.promise); const prover = makeProver(); - const blockProofs = prover.whenBlockProofsReady(); + const subTreeProofs = prover.whenSubTreeProofsReady(); prover.cancel(); gate.reject(new Error('gather aborted by test')); - await expect(blockProofs).rejects.toThrow(/cancelled/); + await expect(subTreeProofs).rejects.toThrow(/cancelled/); await expect(prover.whenDone()).resolves.toBeUndefined(); }); - it('lets a second whenBlockProofsReady caller observe the same rejection', async () => { + it('lets a second whenSubTreeProofsReady caller observe the same rejection', async () => { // Two callers awaiting the same promise both see the rejection — neither leaks an // unhandled rejection (the constructor pre-attaches a noop catch handler). const prover = makeProver(); - const a = prover.whenBlockProofsReady(); - const b = prover.whenBlockProofsReady(); + const a = prover.whenSubTreeProofsReady(); + const b = prover.whenSubTreeProofsReady(); prover.cancel(); await Promise.all([expect(a).rejects.toThrow(/cancelled/), expect(b).rejects.toThrow(/cancelled/)]); await prover.whenDone(); @@ -274,7 +274,7 @@ describe('CheckpointProver', () => { const prover = makeProver(); failure.resolve({ txs: [], missingTxs: [missingHash] }); - await expect(prover.whenBlockProofsReady()).rejects.toThrow(/Txs not found/); + await expect(prover.whenSubTreeProofsReady()).rejects.toThrow(/Txs not found/); // Subsequent cancel is a no-op; no throws. prover.cancel(); expect(prover.isCancelled()).toBe(true); @@ -285,10 +285,10 @@ describe('CheckpointProver', () => { // ---------------- data-plane reorg fork fault ---------------- describe('data-plane reorg fault', () => { - it('rejects whenBlockProofsReady when a world-state fork faults mid-proof', async () => { + it('rejects whenSubTreeProofsReady when a world-state fork faults mid-proof', async () => { // Models the data-plane prune race: gather succeeds and the sub-tree starts, but the // world-state synchronizer has already unwound the base block, so forking it faults inside - // executeCheckpoint. The fault must reject whenBlockProofsReady() AND mark the prover failed, so + // executeCheckpoint. The fault must reject whenSubTreeProofsReady() AND mark the prover failed, so // the SessionManager won't build (or rebuild) an EpochSession over it until a re-add replaces it. txProvider.getTxsForBlock.mockReset(); txProvider.getTxsForBlock.mockResolvedValue({ txs: [], missingTxs: [] }); @@ -310,9 +310,9 @@ describe('CheckpointProver', () => { const prover = makeProver(); - // blockProofs rejects: the fork error aborts the block loop before completion, so the sub-tree + // subTreeProofs rejects: the fork error aborts the block loop before completion, so the sub-tree // never yields proofs. (The raw fork error is logged; the promise settles as not-completed.) - await expect(prover.whenBlockProofsReady()).rejects.toThrow(/did not complete block processing/); + await expect(prover.whenSubTreeProofsReady()).rejects.toThrow(/did not complete block processing/); expect(dbProvider.fork).toHaveBeenCalled(); expect(prover.isFailed()).toBe(true); // The owner is notified exactly once, with this prover, so it can upload a checkpoint post-mortem. @@ -332,6 +332,7 @@ describe('CheckpointProver', () => { attestations: [], previousBlockHeader: {} as BlockHeader, l1ToL2Messages: [], + previousInboxRollingHash: Fr.ZERO, previousArchiveSiblingPath: makeTuple(ARCHIVE_HEIGHT, () => Fr.ZERO), ...overrides, }; diff --git a/yarn-project/prover-node/src/job/checkpoint-prover.ts b/yarn-project/prover-node/src/job/checkpoint-prover.ts index 5a04412bb85a..b3f26dd2f4b0 100644 --- a/yarn-project/prover-node/src/job/checkpoint-prover.ts +++ b/yarn-project/prover-node/src/job/checkpoint-prover.ts @@ -10,7 +10,11 @@ import { type DateProvider, Timer } from '@aztec/foundation/timer'; import { getVKTreeRoot } from '@aztec/noir-protocol-circuits-types/vk-tree'; import { protocolContractsHash } from '@aztec/protocol-contracts'; import type { EpochProverFactory } from '@aztec/prover-client'; -import type { CheckpointSubTreeOrchestrator, ChonkCache, SubTreeResult } from '@aztec/prover-client/orchestrator'; +import type { + CheckpointSubTreeOrchestrator, + CheckpointSubTreeProofs, + ChonkCache, +} from '@aztec/prover-client/orchestrator'; import type { PublicProcessor, PublicProcessorFactory } from '@aztec/simulator/server'; import { PublicSimulatorConfig } from '@aztec/stdlib/avm'; import type { CommitteeAttestation, L2Block } from '@aztec/stdlib/block'; @@ -65,6 +69,8 @@ export type CheckpointProverArgs = { attestations: CommitteeAttestation[]; previousBlockHeader: BlockHeader; l1ToL2Messages: Fr[]; + /** Inbox rolling hash of the previous checkpoint (this checkpoint's chain start); genesis is zero. */ + previousInboxRollingHash: Fr; previousArchiveSiblingPath: Tuple; }; @@ -78,8 +84,8 @@ export type CheckpointProverArgs = { * predecessor but with different content, keys to a distinct prover. * * The prover eagerly starts its own tx gather and sub-tree work in the constructor, so - * callers only need to call `whenBlockProofsReady()` to obtain the resulting block-rollup - * proofs. + * callers only need to call `whenSubTreeProofsReady()` to obtain the resulting block-rollup + * and InboxParity proofs. * * A CheckpointProver does not survive a prune: its sub-tree work forks world-state per * block, and an L1 prune of a base block faults those reads. The store therefore cancels and @@ -97,19 +103,21 @@ export class CheckpointProver { readonly attestations: CommitteeAttestation[]; readonly previousBlockHeader: BlockHeader; readonly l1ToL2Messages: Fr[]; + readonly previousInboxRollingHash: Fr; readonly previousArchiveSiblingPath: Tuple; /** Per-prover tx map — populated by the internal gather. Empty until then. */ readonly txs: Map = new Map(); - /** Resolved by the sub-tree on success, rejected on cancel/failure. */ - private readonly blockProofs: PromiseWithResolvers = promiseWithResolvers(); + /** Resolved by the sub-tree on success, rejected on cancel/failure. Carries the block proofs plus the checkpoint's + * InboxParity proof (which feeds the checkpoint root in the top tree). */ + private readonly subTreeProofs: PromiseWithResolvers = promiseWithResolvers(); // Three independent lifecycle facts — deliberately not collapsed into one status enum, because several // combinations are legal and relied on: a prover can be `completed` and then `cancelled` (routine // teardown of an already-proven checkpoint), or `completed` and then `failed` (block proving was // enqueued, but the sub-tree subsequently faulted). Only `failed` + `cancelled` is excluded — a cancel - // is not a failure (enforced in `failBlockProofs`). + // is not a failure (enforced in `failSubTreeProofs`). /** Block-level proving was fully *enqueued* (a progress marker; the sub-tree may still be proving). */ private completed = false; /** Block proofs rejected for a genuine (non-cancel) reason — a sub-tree or prune-induced fork fault. */ @@ -134,11 +142,12 @@ export class CheckpointProver { this.attestations = args.attestations; this.previousBlockHeader = args.previousBlockHeader; this.l1ToL2Messages = args.l1ToL2Messages; + this.previousInboxRollingHash = args.previousInboxRollingHash; this.previousArchiveSiblingPath = args.previousArchiveSiblingPath; this.id = CheckpointProver.idFor(args.checkpoint); - // Mark blockProofs as observed so a cancel that lands before any consumer awaits + // Mark subTreeProofs as observed so a cancel that lands before any consumer awaits // does not surface as an unhandled rejection. - this.blockProofs.promise.catch(() => {}); + this.subTreeProofs.promise.catch(() => {}); deps.log.info(`Created CheckpointProver ${this.id}`, { checkpointNumber: this.checkpoint.number, epochNumber: this.epochNumber, @@ -179,9 +188,9 @@ export class CheckpointProver { return this.abortController.signal; } - /** Promise that resolves with the block-rollup proofs for this checkpoint (or rejects on cancel/failure). */ - public whenBlockProofsReady(): Promise { - return this.blockProofs.promise; + /** Promise that resolves with the block-rollup proofs and InboxParity proof for this checkpoint (or rejects). */ + public whenSubTreeProofsReady(): Promise { + return this.subTreeProofs.promise; } /** Resolves when all in-flight work for this prover has fully unwound. */ @@ -209,16 +218,16 @@ export class CheckpointProver { this.deps.log.error(`Error in CheckpointProver ${this.id}`, err, { checkpointNumber: this.checkpoint.number, }); - this.failBlockProofs(err instanceof Error ? err : new Error(String(err))); + this.failSubTreeProofs(err instanceof Error ? err : new Error(String(err))); } } /** - * Rejects the block-proof promise and, unless this is a cancellation, records the prover as failed so + * Rejects the sub-tree proof promise and, unless this is a cancellation, records the prover as failed so * the reconciler won't build an EpochSession over it. First rejection wins, so a later duplicate reject * (e.g. the executeCheckpoint `finally`) is a harmless no-op. */ - private failBlockProofs(err: Error): void { + private failSubTreeProofs(err: Error): void { if (!this.cancelled && !this.failed) { this.failed = true; // Notify the owner so it can upload a post-mortem for this checkpoint. Fire-and-forget: the @@ -229,7 +238,7 @@ export class CheckpointProver { this.deps.log.error(`Error in CheckpointProver onFailed callback for ${this.id}`, err); } } - this.blockProofs.reject(err); + this.subTreeProofs.reject(err); } private async gatherTxs(): Promise> { @@ -287,11 +296,12 @@ export class CheckpointProver { this.epochNumber, checkpointConstants, this.l1ToL2Messages, + this.previousInboxRollingHash, this.checkpoint.blocks.length, this.previousBlockHeader, ); subTreeStarted = true; - // Bridge the sub-tree's result onto blockProofs. + // Bridge the sub-tree's result onto subTreeProofs. void this.subTree.getSubTreeResult().then( result => { this.deps.log.info(`Sub-tree block proofs ready for checkpoint ${this.checkpoint.number}`, { @@ -300,9 +310,12 @@ export class CheckpointProver { }); // Spans processing + proving (from executeCheckpoint start, after tx gathering) to proofs ready. this.deps.metrics.recordCheckpointProving(checkpointTimer.ms()); - this.blockProofs.resolve(result.blockProofOutputs); + this.subTreeProofs.resolve({ + blockProofOutputs: result.blockProofOutputs, + inboxParityProof: result.inboxParityProof, + }); }, - err => this.failBlockProofs(err instanceof Error ? err : new Error(String(err))), + err => this.failSubTreeProofs(err instanceof Error ? err : new Error(String(err))), ); if (signal.aborted) { return; @@ -382,7 +395,7 @@ export class CheckpointProver { if (subTreeStarted) { await this.teardownSubTree(); } - this.failBlockProofs(new Error(`Checkpoint ${this.id} did not complete block processing`)); + this.failSubTreeProofs(new Error(`Checkpoint ${this.id} did not complete block processing`)); } } } @@ -415,7 +428,7 @@ export class CheckpointProver { }); } this.abortController.abort(); - this.blockProofs.reject(new Error(`Checkpoint ${this.id} cancelled`)); + this.subTreeProofs.reject(new Error(`Checkpoint ${this.id} cancelled`)); this.cancelPromise = this.runCancel().catch(() => {}); } diff --git a/yarn-project/prover-node/src/job/epoch-proving-job-data.test.ts b/yarn-project/prover-node/src/job/epoch-proving-job-data.test.ts index 6ff3ecc44fb3..58652eb13217 100644 --- a/yarn-project/prover-node/src/job/epoch-proving-job-data.test.ts +++ b/yarn-project/prover-node/src/job/epoch-proving-job-data.test.ts @@ -30,6 +30,7 @@ describe('EpochProvingJobData', () => { [CheckpointNumber(3)]: [Fr.random()], }, previousBlockHeader: BlockHeader.random(), + previousInboxRollingHash: Fr.random(), attestations: times(3, CommitteeAttestation.random), }; diff --git a/yarn-project/prover-node/src/job/epoch-proving-job-data.ts b/yarn-project/prover-node/src/job/epoch-proving-job-data.ts index 6b107b5eb411..c2ee95938d6e 100644 --- a/yarn-project/prover-node/src/job/epoch-proving-job-data.ts +++ b/yarn-project/prover-node/src/job/epoch-proving-job-data.ts @@ -12,6 +12,8 @@ export type EpochProvingJobData = { txs: Map; l1ToL2Messages: Record; previousBlockHeader: BlockHeader; + /** Inbox rolling hash of the checkpoint before the epoch's first checkpoint (its chain start); genesis is zero. */ + previousInboxRollingHash: Fr; attestations: CommitteeAttestation[]; }; @@ -48,6 +50,7 @@ export function serializeEpochProvingJobData(data: EpochProvingJobData): Buffer return serializeToBuffer( data.epochNumber, data.previousBlockHeader, + data.previousInboxRollingHash, checkpoints.length, ...checkpoints, txs.length, @@ -63,6 +66,7 @@ export function deserializeEpochProvingJobData(buf: Buffer): EpochProvingJobData const reader = BufferReader.asReader(buf); const epochNumber = EpochNumber(reader.readNumber()); const previousBlockHeader = reader.readObject(BlockHeader); + const previousInboxRollingHash = Fr.fromBuffer(reader); const checkpoints = reader.readVector(Checkpoint); const txArray = reader.readVector(Tx); @@ -78,5 +82,13 @@ export function deserializeEpochProvingJobData(buf: Buffer): EpochProvingJobData const txs = new Map(txArray.map(tx => [tx.getTxHash().toString(), tx])); - return { epochNumber, previousBlockHeader, checkpoints, txs, l1ToL2Messages, attestations }; + return { + epochNumber, + previousBlockHeader, + previousInboxRollingHash, + checkpoints, + txs, + l1ToL2Messages, + attestations, + }; } diff --git a/yarn-project/prover-node/src/job/epoch-session.test.ts b/yarn-project/prover-node/src/job/epoch-session.test.ts index 7c6512c2fd02..15281f684f92 100644 --- a/yarn-project/prover-node/src/job/epoch-session.test.ts +++ b/yarn-project/prover-node/src/job/epoch-session.test.ts @@ -282,20 +282,20 @@ describe('EpochSession', () => { // ---------------- checkpoint failure ---------------- describe('checkpoint that fails to prove', () => { - it('ends the session in "stopped" (not "failed") when a checkpoint\'s blockProofs reject', async () => { + it('ends the session in "stopped" (not "failed") when a checkpoint\'s subTreeProofs reject', async () => { // Build a prover whose block-rollup proofs are guaranteed to reject — this mirrors // the production path where CheckpointProver.executeCheckpoint catches an internal - // error (e.g. a data-plane reorg fork fault) and rejects its blockProofs promise. + // error (e.g. a data-plane reorg fork fault) and rejects its subTreeProofs promise. // The session must NOT declare the epoch failed: it ends in the non-declaring terminal // 'stopped', leaving the reconciler free to rebuild it over current canonical content. - const failingProver = makeStubProver(cp, { blockProofsError: new Error('block 7 proving failed') }); + const failingProver = makeStubProver(cp, { subTreeProofsError: new Error('block 7 proving failed') }); const session = new EpochSession( makeSpec(), [failingProver], makeDeps({ // Override mirrors what the real topTree.prove(...) does: awaits each prover's - // blockProofs and propagates the rejection up. - hooks: { topTreeProveOverride: () => failingProver.whenBlockProofsReady().then(() => synthProof) }, + // subTreeProofs and propagates the rejection up. + hooks: { topTreeProveOverride: () => failingProver.whenSubTreeProofsReady().then(() => synthProof) }, }), ); const state = await session.start(); @@ -308,12 +308,12 @@ describe('EpochSession', () => { }); it('whenDone resolves to "stopped" so callers observing the lifecycle agree with the return value', async () => { - const failingProver = makeStubProver(cp, { blockProofsError: new Error('boom') }); + const failingProver = makeStubProver(cp, { subTreeProofsError: new Error('boom') }); const session = new EpochSession( makeSpec(), [failingProver], makeDeps({ - hooks: { topTreeProveOverride: () => failingProver.whenBlockProofsReady().then(() => synthProof) }, + hooks: { topTreeProveOverride: () => failingProver.whenSubTreeProofsReady().then(() => synthProof) }, }), ); const startResult = session.start(); @@ -322,12 +322,12 @@ describe('EpochSession', () => { }); it('ends the session in "stopped" (not "failed") when a prover was cancelled by a prune (isCancelled, not isFailed)', async () => { - // A control-plane prune cancels the prover: its blockProofs reject with "cancelled" and it reports + // A control-plane prune cancels the prover: its subTreeProofs reject with "cancelled" and it reports // isCancelled()===true / isFailed()===false. If that rejection reaches start()'s catch before the // reconcile marks the session 'cancelled', it must NOT be classified 'failed' (which would trigger a // spurious full-snapshot upload) — a cancelled prover is prune-ambiguous, so classify 'stopped'. const cancelledProver = makeStubProver(cp, { - blockProofsError: new Error('Checkpoint cancelled'), + subTreeProofsError: new Error('Checkpoint cancelled'), isFailed: false, isCancelled: true, }); @@ -335,7 +335,7 @@ describe('EpochSession', () => { makeSpec(), [cancelledProver], makeDeps({ - hooks: { topTreeProveOverride: () => cancelledProver.whenBlockProofsReady().then(() => synthProof) }, + hooks: { topTreeProveOverride: () => cancelledProver.whenSubTreeProofsReady().then(() => synthProof) }, }), ); const state = await session.start(); @@ -465,24 +465,24 @@ class TestEpochSession extends EpochSession { * Minimal CheckpointProver-shaped stub: provides everything the TopTreeJob and EpochSession * read off a prover, without standing up the actual eager gather/sub-tree pipeline. * - * Pass `blockProofsError` to simulate a checkpoint that fails to prove — its - * `whenBlockProofsReady()` will reject with the supplied error, mirroring the production + * Pass `subTreeProofsError` to simulate a checkpoint that fails to prove — its + * `whenSubTreeProofsReady()` will reject with the supplied error, mirroring the production * path where CheckpointProver.executeCheckpoint catches an internal failure and rejects - * its blockProofs promise. + * its subTreeProofs promise. */ function makeStubProver( checkpoint: Checkpoint, - opts: { blockProofsError?: Error; isFailed?: boolean; isCancelled?: boolean } = {}, + opts: { subTreeProofsError?: Error; isFailed?: boolean; isCancelled?: boolean } = {}, ): CheckpointProver { const id = CheckpointProver.idFor(checkpoint); - // By default whenBlockProofsReady never resolves in these tests; the prove override + // By default whenSubTreeProofsReady never resolves in these tests; the prove override // bypasses any path that would actually await it. - const blockProofs: Promise = opts.blockProofsError - ? Promise.reject(opts.blockProofsError) + const subTreeProofs: Promise = opts.subTreeProofsError + ? Promise.reject(opts.subTreeProofsError) : new Promise(() => {}); // Suppress unhandled-rejection noise — tests that need the rejection observe it // explicitly via the proveOverride hook. - blockProofs.catch(() => {}); + subTreeProofs.catch(() => {}); return { id, checkpoint, @@ -493,11 +493,11 @@ function makeStubProver( l1ToL2Messages: [], previousArchiveSiblingPath: makeTuple(ARCHIVE_HEIGHT, () => Fr.ZERO), txs: new Map(), - whenBlockProofsReady: () => blockProofs, + whenSubTreeProofsReady: () => subTreeProofs, isCancelled: () => opts.isCancelled ?? false, - // A prover configured with a blockProofsError is one whose block proofs rejected — i.e. failed, + // A prover configured with a subTreeProofsError is one whose sub-tree proofs rejected — i.e. failed, // unless the caller decouples the two (e.g. to model a cancelled-but-not-failed prune). - isFailed: () => opts.isFailed ?? opts.blockProofsError !== undefined, + isFailed: () => opts.isFailed ?? opts.subTreeProofsError !== undefined, cancel: () => {}, whenDone: () => Promise.resolve(), getAbortSignal: () => new AbortController().signal, diff --git a/yarn-project/prover-node/src/job/top-tree-job.ts b/yarn-project/prover-node/src/job/top-tree-job.ts index 1290ea9de381..42d8b868feef 100644 --- a/yarn-project/prover-node/src/job/top-tree-job.ts +++ b/yarn-project/prover-node/src/job/top-tree-job.ts @@ -42,7 +42,7 @@ export type TopTreeJobHooks = { /** * Self-contained top-tree job. Constructed from a snapshot of `CheckpointProver`s; runs - * `topTree.prove(...)` against their pending `blockProofs` promises and exposes the + * `topTree.prove(...)` against their pending `subTreeProofs` promises and exposes the * final epoch proof via `result`. * */ @@ -185,7 +185,7 @@ export class TopTreeJob { ); const checkpointData: CheckpointTopTreeData[] = this.snapshot.map(j => ({ - blockProofs: j.whenBlockProofsReady(), + subTreeProofs: j.whenSubTreeProofsReady(), l2ToL1MsgsPerBlock: j.checkpoint.blocks.map(b => b.body.txEffects.map(tx => tx.l2ToL1Msgs)), blobFields: j.checkpoint.toBlobFields(), previousBlockHeader: j.previousBlockHeader, diff --git a/yarn-project/prover-node/src/prover-node-publisher.ts b/yarn-project/prover-node/src/prover-node-publisher.ts index 0ff328189dea..7e5cc668c091 100644 --- a/yarn-project/prover-node/src/prover-node-publisher.ts +++ b/yarn-project/prover-node/src/prover-node-publisher.ts @@ -333,6 +333,8 @@ export class ProverNodePublisher { previousArchive: args.publicInputs.previousArchiveRoot.toString(), endArchive: args.publicInputs.endArchiveRoot.toString(), outHash: args.publicInputs.outHash.toString(), + previousInboxRollingHash: args.publicInputs.previousInboxRollingHash.toString(), + endInboxRollingHash: args.publicInputs.endInboxRollingHash.toString(), proverId: EthAddress.fromField(args.publicInputs.constants.proverId).toString(), } /*_args*/, args.headers.map(header => header.toViem()) /*_headers*/, @@ -375,10 +377,12 @@ export class ProverNodePublisher { * [0] previousArchiveRoot * [1] endArchiveRoot * [2] outHash - * [3 .. 3+N-1] checkpointHeaderHashes[i] for i in 0..N-1 (N = MAX_CHECKPOINTS_PER_EPOCH) - * [3+N .. 3+3N-1] fees[i] = (recipient, value) for i in 0..N-1 - * [3+3N .. 3+3N+4] EpochConstantData (chainId, version, vkTreeRoot, protocolContractsHash, proverId) - * [3+3N+5 ..] blobPublicInputs (FinalBlobAccumulator) + * [3] previousInboxRollingHash + * [4] endInboxRollingHash + * [5 .. 5+N-1] checkpointHeaderHashes[i] for i in 0..N-1 (N = MAX_CHECKPOINTS_PER_EPOCH) + * [5+N .. 5+3N-1] fees[i] = (recipient, value) for i in 0..N-1 + * [5+3N .. 5+3N+4] EpochConstantData (chainId, version, vkTreeRoot, protocolContractsHash, proverId) + * [5+3N+5 ..] blobPublicInputs (FinalBlobAccumulator) */ async function reportPublicInputsMismatch(input: { rollupPublicInputs: readonly Fr[]; @@ -390,7 +394,8 @@ async function reportPublicInputsMismatch(input: { }): Promise { const { rollupPublicInputs, argsPublicInputs, fromCheckpoint, toCheckpoint, rollupContract, log } = input; const N = MAX_CHECKPOINTS_PER_EPOCH; - const constantsStart = 3 + 3 * N; + const headerHashesStart = 5; + const constantsStart = headerHashesStart + 3 * N; const blobStart = constantsStart + 5; const constantLabels = ['chainId', 'version', 'vkTreeRoot', 'protocolContractsHash', 'proverId']; @@ -410,11 +415,15 @@ async function reportPublicInputsMismatch(input: { label = 'endArchiveRoot'; } else if (i === 2) { label = 'outHash'; - } else if (i < 3 + N) { - checkpointIndex = i - 3; + } else if (i === 3) { + label = 'previousInboxRollingHash'; + } else if (i === 4) { + label = 'endInboxRollingHash'; + } else if (i < headerHashesStart + N) { + checkpointIndex = i - headerHashesStart; label = `checkpointHeaderHashes[${checkpointIndex}]`; - } else if (i < 3 + 3 * N) { - const feePairIndex = i - (3 + N); + } else if (i < headerHashesStart + 3 * N) { + const feePairIndex = i - (headerHashesStart + N); const feeIndex = Math.floor(feePairIndex / 2); const sub = feePairIndex % 2 === 0 ? 'recipient' : 'value'; label = `fees[${feeIndex}].${sub}`; diff --git a/yarn-project/prover-node/src/prover-node.test.ts b/yarn-project/prover-node/src/prover-node.test.ts index 24fd2b1adcda..1742953aa752 100644 --- a/yarn-project/prover-node/src/prover-node.test.ts +++ b/yarn-project/prover-node/src/prover-node.test.ts @@ -723,7 +723,7 @@ describe('ProverNode', () => { ): Checkpoint { return { number: CheckpointNumber(checkpointNumber), - header: { slotNumber: SlotNumber(slot) }, + header: { slotNumber: SlotNumber(slot), inboxRollingHash: Fr.ZERO }, archive: { root: archiveRoot }, blocks: [{ number: blockNumber, header: { hash: () => Promise.resolve('0x01') } }], hash: () => new Fr(checkpointNumber), @@ -745,9 +745,19 @@ describe('ProverNode', () => { */ function mineCheckpoint(checkpoint: Checkpoint): L2BlockStreamEvent { mined.set(Number(checkpoint.number), checkpoint); - l2BlockSource.getCheckpoint.mockImplementation((query: any) => - Promise.resolve('number' in query ? makeMaybePublished(mined.get(Number(query.number))) : undefined), - ); + l2BlockSource.getCheckpoint.mockImplementation((query: any) => { + if (!('number' in query)) { + return Promise.resolve(undefined); + } + const number = Number(query.number); + const found = mined.get(number); + // Ancestors below the mined window exist on chain but are irrelevant to the scenario; serve a synthetic + // parent so inbox rolling-hash sourcing for the earliest mined checkpoint resolves. + const belowWindow = number > 0 && number < Math.min(...mined.keys()); + return Promise.resolve( + makeMaybePublished(found ?? (belowWindow ? makeCheckpoint(number, number, number) : undefined)), + ); + }); l2BlockSource.getCheckpointsData.mockImplementation((query: any) => { if (!('from' in query)) { return Promise.resolve([]); diff --git a/yarn-project/prover-node/src/prover-node.ts b/yarn-project/prover-node/src/prover-node.ts index 5f4c59250153..d3d6883beb9d 100644 --- a/yarn-project/prover-node/src/prover-node.ts +++ b/yarn-project/prover-node/src/prover-node.ts @@ -3,6 +3,7 @@ import type { RollupContract } from '@aztec/ethereum/contracts'; import type { Delayer } from '@aztec/ethereum/l1-tx-utils'; import { BlockNumber, CheckpointNumber, EpochNumber } from '@aztec/foundation/branded-types'; import { assertRequired, compact, pick } from '@aztec/foundation/collection'; +import { Fr } from '@aztec/foundation/curves/bn254'; import { memoize } from '@aztec/foundation/decorators'; import { createLogger } from '@aztec/foundation/log'; import { RunningPromise } from '@aztec/foundation/running-promise'; @@ -350,6 +351,7 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra const previousBlockNumber = BlockNumber(checkpoint.blocks[0].number - 1); const previousBlockHeader = await this.gatherPreviousBlockHeader(previousBlockNumber); const l1ToL2Messages = await this.l1ToL2MessageSource.getL1ToL2Messages(checkpoint.number); + const previousInboxRollingHash = await this.gatherPreviousInboxRollingHash(checkpoint.number); const lastBlock = checkpoint.blocks.at(-1)!; const lastBlockHash = await lastBlock.header.hash(); await this.worldState.syncImmediate(lastBlock.number, lastBlockHash); @@ -361,10 +363,27 @@ export class ProverNode implements L2BlockStreamEventHandler, ProverNodeApi, Tra attestations, previousBlockHeader, l1ToL2Messages, + previousInboxRollingHash, previousArchiveSiblingPath, }; } + /** + * Sources the inbox rolling hash chain-start for a checkpoint: the previous checkpoint's `inboxRollingHash`, or zero + * for the genesis checkpoint. The prover threads this into the base parity circuits so the rebuilt checkpoint header + * matches the proposer's. + */ + private async gatherPreviousInboxRollingHash(checkpointNumber: CheckpointNumber): Promise { + if (checkpointNumber <= 1) { + return Fr.ZERO; + } + const previous = await this.l2BlockSource.getCheckpoint({ number: CheckpointNumber(checkpointNumber - 1) }); + if (!previous) { + throw new Error(`Previous checkpoint ${checkpointNumber - 1} not found when sourcing inbox rolling hash`); + } + return previous.checkpoint.header.inboxRollingHash; + } + /** * Marks every prover orphaned by the prune as pruned, clamps the catch-up cursor below the prune target's * checkpoint, and notifies the session manager. Keyed off the prune target block (the highest surviving block) diff --git a/yarn-project/prover-node/src/session-manager.ts b/yarn-project/prover-node/src/session-manager.ts index 3a42a59e74dc..300173c436eb 100644 --- a/yarn-project/prover-node/src/session-manager.ts +++ b/yarn-project/prover-node/src/session-manager.ts @@ -453,6 +453,7 @@ export class SessionManager { txs, l1ToL2Messages, previousBlockHeader: checkpoints[0].previousBlockHeader, + previousInboxRollingHash: checkpoints[0].previousInboxRollingHash, attestations: [], }; } diff --git a/yarn-project/pxe/src/storage/backwards_compatibility_tests/__snapshots__/L2TipsKVStore.json b/yarn-project/pxe/src/storage/backwards_compatibility_tests/__snapshots__/L2TipsKVStore.json index ae0aeba8bf19..e83ff396e83e 100644 --- a/yarn-project/pxe/src/storage/backwards_compatibility_tests/__snapshots__/L2TipsKVStore.json +++ b/yarn-project/pxe/src/storage/backwards_compatibility_tests/__snapshots__/L2TipsKVStore.json @@ -16,7 +16,7 @@ "pxe_l2_tip_checkpoints": [ { "key": "utf8:checkpointed", - "value": "{\"number\":47,\"hash\":\"0x00e66a45cc6583f772f44bdb5ae6535cf821a59a3d832702a125f0c57f6228ef\"}" + "value": "{\"number\":47,\"hash\":\"0x009bac3aae6ac2c7945a4686ec07381ac88bbd323cbfaccd6dffea9b254ae820\"}" }, { "key": "utf8:proven", diff --git a/yarn-project/pxe/src/storage/backwards_compatibility_tests/schema_tests.ts b/yarn-project/pxe/src/storage/backwards_compatibility_tests/schema_tests.ts index a8561507d41d..a9a75a77ffbc 100644 --- a/yarn-project/pxe/src/storage/backwards_compatibility_tests/schema_tests.ts +++ b/yarn-project/pxe/src/storage/backwards_compatibility_tests/schema_tests.ts @@ -277,6 +277,7 @@ export const SCHEMA_TESTS: readonly SchemaTest[] = [ new Fr(7n), new Fr(11n), new Fr(13n), + new Fr(15n), new Fr(17n), SlotNumber(19), 23n, diff --git a/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts b/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts index 2742610426b5..31f948406db4 100644 --- a/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts +++ b/yarn-project/sequencer-client/src/publisher/l1_publisher.integration.test.ts @@ -472,6 +472,7 @@ describe('L1Publisher integration', () => { checkpointConstants, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, tempFork, ); diff --git a/yarn-project/sequencer-client/src/publisher/write_json.ts b/yarn-project/sequencer-client/src/publisher/write_json.ts index 7e07dc7bc028..401a94908a6f 100644 --- a/yarn-project/sequencer-client/src/publisher/write_json.ts +++ b/yarn-project/sequencer-client/src/publisher/write_json.ts @@ -56,6 +56,7 @@ export async function writeJson( blockHeadersHash: asHex(checkpointHeader.blockHeadersHash), blobsHash: asHex(checkpointHeader.blobsHash), inHash: asHex(checkpointHeader.inHash), + inboxRollingHash: asHex(checkpointHeader.inboxRollingHash), outHash: asHex(checkpointHeader.epochOutHash), slotNumber: Number(checkpointHeader.slotNumber), timestamp: Number(checkpointHeader.timestamp), diff --git a/yarn-project/sequencer-client/src/sequencer/automine/automine_sequencer.ts b/yarn-project/sequencer-client/src/sequencer/automine/automine_sequencer.ts index ef1c5455768a..3c43860a8088 100644 --- a/yarn-project/sequencer-client/src/sequencer/automine/automine_sequencer.ts +++ b/yarn-project/sequencer-client/src/sequencer/automine/automine_sequencer.ts @@ -13,7 +13,7 @@ import type { P2PClient as ConcreteP2PClient, P2P } from '@aztec/p2p'; import { settleEpochOutbox } from '@aztec/prover-client/test'; import type { AztecAddress } from '@aztec/stdlib/aztec-address'; import { CommitteeAttestationsAndSigners, type L2Block, type L2BlockSource } from '@aztec/stdlib/block'; -import { getPreviousCheckpointOutHashes } from '@aztec/stdlib/checkpoint'; +import { getPreviousCheckpointInboxRollingHash, getPreviousCheckpointOutHashes } from '@aztec/stdlib/checkpoint'; import type { ChainConfig } from '@aztec/stdlib/config'; import { type L1RollupConstants, @@ -458,6 +458,12 @@ export class AutomineSequencer { log: this.log, }); + const previousInboxRollingHash = await getPreviousCheckpointInboxRollingHash({ + blockSource: this.deps.l2BlockSource, + checkpointNumber, + log: this.log, + }); + const feeAssetPriceModifier = await this.publisher.getFeeAssetPriceModifier(); await using fork = await this.deps.worldState.fork(syncedToBlockNumber, { closeDelayMs: 0 }); @@ -468,6 +474,7 @@ export class AutomineSequencer { feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, fork, this.log.getBindings(), ); diff --git a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts index bac6571e1b66..1dad18d8fdf8 100644 --- a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts +++ b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.test.ts @@ -249,6 +249,11 @@ describe('CheckpointProposalJob', () => { l2BlockSource = mock(); l2BlockSource.getCheckpointsData.mockResolvedValue([]); + // The job sources the parent checkpoint's inboxRollingHash; serve an empty parent header so jobs beyond + // the genesis checkpoint resolve their chain start. + l2BlockSource.getCheckpointData.mockImplementation(query => + Promise.resolve('number' in query ? ({ header: CheckpointHeader.empty() } as CheckpointData) : undefined), + ); // The (always-on) pipelined submission path waits for the archiver to confirm the parent // checkpoint on L1 before enqueuing the proposal. For the default job (checkpoint 1, no // proposed parent), the parent is genesis (cp 0), so a synced archiver reporting a diff --git a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts index 729aa8039b87..6fa6212fb0f8 100644 --- a/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts +++ b/yarn-project/sequencer-client/src/sequencer/checkpoint_proposal_job.ts @@ -39,6 +39,7 @@ import { type Checkpoint, type ProposedCheckpointData, buildCheckpointSimulationOverridesPlan, + getPreviousCheckpointInboxRollingHash, getPreviousCheckpointOutHashes, validateCheckpoint, } from '@aztec/stdlib/checkpoint'; @@ -629,6 +630,16 @@ export class CheckpointProposalJob implements Traceable { log: this.log, }); + // Chain start for this checkpoint's inbox rolling hash: the parent checkpoint's `inboxRollingHash`. Unlike the + // epoch out-hash tree, the chain is continuous across epochs, so this is always the immediately preceding + // checkpoint's value (or zero at genesis). + const previousInboxRollingHash = await getPreviousCheckpointInboxRollingHash({ + blockSource: this.l2BlockSource, + checkpointNumber: this.checkpointNumber, + proposedCheckpointData: this.proposedCheckpointData, + log: this.log, + }); + // Anchor the modifier to the predicted parent fee header: L1 will apply it against // that, not against the latest published checkpoint (which lags by one under pipelining). const predictedParentEthPerFeeAssetE12 = @@ -645,6 +656,7 @@ export class CheckpointProposalJob implements Traceable { feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, fork, this.log.getBindings(), ); diff --git a/yarn-project/sequencer-client/src/test/mock_checkpoint_builder.ts b/yarn-project/sequencer-client/src/test/mock_checkpoint_builder.ts index f0a6afca82cc..b7cfae439637 100644 --- a/yarn-project/sequencer-client/src/test/mock_checkpoint_builder.ts +++ b/yarn-project/sequencer-client/src/test/mock_checkpoint_builder.ts @@ -263,6 +263,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder { feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], + _previousInboxRollingHash: Fr, _fork: MerkleTreeWriteOperations, ): Promise { this.startCheckpointCalls.push({ @@ -289,6 +290,7 @@ export class MockCheckpointsBuilder implements ICheckpointsBuilder { feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], + _previousInboxRollingHash: Fr, _fork: MerkleTreeWriteOperations, existingBlocks: L2Block[] = [], ): Promise { diff --git a/yarn-project/sequencer-client/src/test/utils.ts b/yarn-project/sequencer-client/src/test/utils.ts index 4bee7eb50f2d..92845b668f07 100644 --- a/yarn-project/sequencer-client/src/test/utils.ts +++ b/yarn-project/sequencer-client/src/test/utils.ts @@ -123,6 +123,7 @@ function createCheckpointHeaderFromBlock(block: L2Block): CheckpointHeader { Fr.random(), // blockHeadersHash - mock value for testing Fr.random(), // blobsHash - mock value for testing Fr.random(), // inHash - mock value for testing + Fr.random(), // inboxRollingHash - mock value for testing Fr.random(), // outHash - mock value for testing gv.slotNumber, gv.timestamp, diff --git a/yarn-project/stdlib/src/checkpoint/index.ts b/yarn-project/stdlib/src/checkpoint/index.ts index 8a0432995659..76c5eda642c3 100644 --- a/yarn-project/stdlib/src/checkpoint/index.ts +++ b/yarn-project/stdlib/src/checkpoint/index.ts @@ -3,6 +3,7 @@ export * from './checkpoint_data.js'; export * from './checkpoint_info.js'; export * from './checkpoint_reexecution_tracker.js'; export * from './digest.js'; +export * from './previous_checkpoint_inbox_rolling_hash.js'; export * from './previous_checkpoint_out_hashes.js'; export * from './published_checkpoint.js'; export * from './simulation_overrides.js'; diff --git a/yarn-project/stdlib/src/checkpoint/previous_checkpoint_inbox_rolling_hash.ts b/yarn-project/stdlib/src/checkpoint/previous_checkpoint_inbox_rolling_hash.ts new file mode 100644 index 000000000000..0e54bf0f5d6a --- /dev/null +++ b/yarn-project/stdlib/src/checkpoint/previous_checkpoint_inbox_rolling_hash.ts @@ -0,0 +1,46 @@ +import { CheckpointNumber } from '@aztec/foundation/branded-types'; +import { Fr } from '@aztec/foundation/curves/bn254'; +import type { Logger } from '@aztec/foundation/log'; + +import type { L2BlockSource } from '../block/l2_block_source.js'; +import type { ProposedCheckpointData } from './checkpoint_data.js'; + +/** + * Returns the inbox rolling hash chain-start for `checkpointNumber`: the `inboxRollingHash` of the immediately + * preceding checkpoint. Unlike the epoch out-hash tree, the rolling-hash chain is continuous across epoch boundaries, + * so the parent is always `checkpointNumber - 1` regardless of epoch. The genesis checkpoint (and the first checkpoint + * built on it) starts the chain at zero. + * + * Under proposer pipelining the parent may not be confirmed on L1 yet, so the locally-known proposed checkpoint is + * preferred when it is the parent, mirroring `getPreviousCheckpointOutHashes`. + */ +export async function getPreviousCheckpointInboxRollingHash(input: { + blockSource: Pick; + checkpointNumber: CheckpointNumber; + proposedCheckpointData?: ProposedCheckpointData; + log?: Logger; +}): Promise { + const { blockSource, checkpointNumber, proposedCheckpointData, log } = input; + if (checkpointNumber <= 1) { + return Fr.ZERO; + } + + const parent = CheckpointNumber(checkpointNumber - 1); + + if (proposedCheckpointData?.checkpointNumber === parent) { + log?.debug(`Using pipelined parent cp ${parent} inbox rolling hash for cp ${checkpointNumber}`); + return proposedCheckpointData.header.inboxRollingHash; + } + + const confirmed = await blockSource.getCheckpointData({ number: parent }); + if (confirmed) { + return confirmed.header.inboxRollingHash; + } + + const proposed = await blockSource.getProposedCheckpointData({ number: parent }); + if (proposed) { + return proposed.header.inboxRollingHash; + } + + throw new Error(`Cannot source inbox rolling hash for parent checkpoint ${parent} of checkpoint ${checkpointNumber}`); +} diff --git a/yarn-project/stdlib/src/interfaces/block-builder.ts b/yarn-project/stdlib/src/interfaces/block-builder.ts index 7c39955d78dd..a925cfd2c08c 100644 --- a/yarn-project/stdlib/src/interfaces/block-builder.ts +++ b/yarn-project/stdlib/src/interfaces/block-builder.ts @@ -156,6 +156,7 @@ export interface ICheckpointsBuilder { feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], + previousInboxRollingHash: Fr, fork: MerkleTreeWriteOperations, bindings?: LoggerBindings, ): Promise; diff --git a/yarn-project/stdlib/src/interfaces/proving-job-source.test.ts b/yarn-project/stdlib/src/interfaces/proving-job-source.test.ts index f37a4832f708..9dcf9d2ec8aa 100644 --- a/yarn-project/stdlib/src/interfaces/proving-job-source.test.ts +++ b/yarn-project/stdlib/src/interfaces/proving-job-source.test.ts @@ -1,16 +1,19 @@ import { NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH } from '@aztec/constants'; import { EpochNumber } from '@aztec/foundation/branded-types'; +import { jsonParseWithSchema, jsonStringify } from '@aztec/foundation/json-rpc'; import { type JsonRpcTestContext, createJsonRpcTestSetup } from '@aztec/foundation/json-rpc/test'; import { ProvingRequestType } from '../proofs/proving_request_type.js'; import { makeRecursiveProof } from '../proofs/recursive_proof.js'; +import { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js'; import { TxRollupPublicInputs } from '../rollup/tx_rollup_public_inputs.js'; +import { makeBlockRollupPublicInputs } from '../tests/factories.js'; import { VerificationKeyData } from '../vks/verification_key.js'; import { type ProvingJobSource, ProvingJobSourceSchema } from './proving-job-source.js'; import { type ProofUri, type ProvingJob, - type ProvingJobResult, + ProvingJobResult, type ProvingRequestResultFor, makePublicInputsAndRecursiveProof, } from './proving-job.js'; @@ -63,6 +66,28 @@ describe('ProvingJobSourceSchema', () => { }); }); +describe('ProvingJobResult', () => { + it('round-trips a message-only block-root rollup result through the schema', () => { + // The message-only block-root proof type must survive serialization: a checkpoint that builds a message-only + // block produces this result, and the proof store decodes it via the ProvingJobResult schema. Omitting it from + // the union throws "Invalid discriminator value" and stalls proving. + const result: ProvingJobResult = { + type: ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP, + result: makePublicInputsAndRecursiveProof< + BlockRollupPublicInputs, + typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH + >( + makeBlockRollupPublicInputs(), + makeRecursiveProof(NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH), + VerificationKeyData.makeFakeRollupHonk(), + ), + }; + + const roundTripped = jsonParseWithSchema(jsonStringify(result), ProvingJobResult); + expect(roundTripped.type).toEqual(ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP); + }); +}); + class MockProvingJobSource implements ProvingJobSource { getProvingJob(): Promise { return Promise.resolve({ diff --git a/yarn-project/stdlib/src/interfaces/proving-job.ts b/yarn-project/stdlib/src/interfaces/proving-job.ts index a84e82b9af2b..b7e31df2f5b3 100644 --- a/yarn-project/stdlib/src/interfaces/proving-job.ts +++ b/yarn-project/stdlib/src/interfaces/proving-job.ts @@ -11,9 +11,8 @@ import { z } from 'zod'; import { AvmCircuitInputs } from '../avm/avm.js'; import { AvmProvingRequestSchema } from '../avm/avm_proving_request.js'; -import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js'; +import { InboxParityPrivateInputs } from '../parity/inbox_parity_private_inputs.js'; import { ParityPublicInputs } from '../parity/parity_public_inputs.js'; -import { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js'; import { ProvingRequestType } from '../proofs/proving_request_type.js'; import { RecursiveProof } from '../proofs/recursive_proof.js'; import { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js'; @@ -21,6 +20,7 @@ import { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js import { BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, + BlockRootMsgsOnlyRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, @@ -81,8 +81,7 @@ export function makePublicInputsAndRecursiveProof; export type ProvingJobResultsMap = { @@ -348,6 +354,10 @@ export type ProvingJobResultsMap = { BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH >; + [ProvingRequestType.BLOCK_ROOT_MSGS_ONLY_ROLLUP]: PublicInputsAndRecursiveProof< + BlockRollupPublicInputs, + typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH + >; [ProvingRequestType.BLOCK_ROOT_ROLLUP]: PublicInputsAndRecursiveProof< BlockRollupPublicInputs, typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH @@ -377,11 +387,7 @@ export type ProvingJobResultsMap = { typeof NESTED_RECURSIVE_ROLLUP_HONK_PROOF_LENGTH >; [ProvingRequestType.ROOT_ROLLUP]: PublicInputsAndRecursiveProof; - [ProvingRequestType.PARITY_BASE]: PublicInputsAndRecursiveProof; - [ProvingRequestType.PARITY_ROOT]: PublicInputsAndRecursiveProof< - ParityPublicInputs, - typeof NESTED_RECURSIVE_PROOF_LENGTH - >; + [ProvingRequestType.INBOX_PARITY]: PublicInputsAndRecursiveProof; }; export type ProvingRequestResultFor = { type: T; result: ProvingJobResultsMap[T] }; diff --git a/yarn-project/stdlib/src/interfaces/server_circuit_prover.ts b/yarn-project/stdlib/src/interfaces/server_circuit_prover.ts index 21f1ea48f2d5..48b4514b7f6b 100644 --- a/yarn-project/stdlib/src/interfaces/server_circuit_prover.ts +++ b/yarn-project/stdlib/src/interfaces/server_circuit_prover.ts @@ -6,15 +6,15 @@ import type { } from '@aztec/constants'; import type { AvmCircuitInputs } from '../avm/avm.js'; -import type { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js'; +import type { InboxParityPrivateInputs } from '../parity/inbox_parity_private_inputs.js'; import type { ParityPublicInputs } from '../parity/parity_public_inputs.js'; -import type { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js'; import type { RecursiveProof } from '../proofs/recursive_proof.js'; import type { BlockMergeRollupPrivateInputs } from '../rollup/block_merge_rollup_private_inputs.js'; import type { BlockRollupPublicInputs } from '../rollup/block_rollup_public_inputs.js'; import type { BlockRootEmptyTxFirstRollupPrivateInputs, BlockRootFirstRollupPrivateInputs, + BlockRootMsgsOnlyRollupPrivateInputs, BlockRootRollupPrivateInputs, BlockRootSingleTxFirstRollupPrivateInputs, BlockRootSingleTxRollupPrivateInputs, @@ -42,25 +42,16 @@ import type { PublicInputsAndRecursiveProof } from './proving-job.js'; */ export interface ServerCircuitProver { /** - * Creates a proof for the given input. - * @param input - Input to the circuit. + * Creates the checkpoint's single InboxParity proof. The circuit variant (ladder size) is selected from + * `inputs.size`. + * @param inputs - Input to the circuit. */ - getBaseParityProof( - inputs: ParityBasePrivateInputs, + getInboxParityProof( + inputs: InboxParityPrivateInputs, signal?: AbortSignal, epochNumber?: number, ): Promise>; - /** - * Creates a proof for the given input. - * @param input - Input to the circuit. - */ - getRootParityProof( - inputs: ParityRootPrivateInputs, - signal?: AbortSignal, - epochNumber?: number, - ): Promise>; - getPublicChonkVerifierProof( inputs: PublicChonkVerifierPrivateInputs, signal?: AbortSignal, @@ -129,6 +120,12 @@ export interface ServerCircuitProver { epochNumber?: number, ): Promise>; + getBlockRootMsgsOnlyRollupProof( + input: BlockRootMsgsOnlyRollupPrivateInputs, + signal?: AbortSignal, + epochNumber?: number, + ): Promise>; + /** * Creates a proof for the given input. * @param input - Input to the circuit. diff --git a/yarn-project/stdlib/src/messaging/inbox_rolling_hash.test.ts b/yarn-project/stdlib/src/messaging/inbox_rolling_hash.test.ts new file mode 100644 index 000000000000..aeba869aaaed --- /dev/null +++ b/yarn-project/stdlib/src/messaging/inbox_rolling_hash.test.ts @@ -0,0 +1,48 @@ +import { Fr } from '@aztec/foundation/curves/bn254'; + +import { accumulateInboxRollingHash, updateInboxRollingHash } from './inbox_rolling_hash.js'; + +describe('inbox rolling hash', () => { + // Shared test vectors pinned against the noir `accumulate_inbox_rolling_hash` helper (FI-02). Any divergence here + // means the L1 / noir / TS rolling hashes would disagree. + const range = (from: number, to: number) => Array.from({ length: to - from + 1 }, (_, i) => new Fr(from + i)); + + it('chains a single leaf from zero', () => { + expect(accumulateInboxRollingHash(Fr.ZERO, [new Fr(11)])).toEqual( + Fr.fromHexString('0x00815fb1e9d2076ae5761439b6144ad11da69eb6c41ab2aca39e770407ad8d12'), + ); + }); + + it('chains three leaves from zero', () => { + expect(accumulateInboxRollingHash(Fr.ZERO, [new Fr(11), new Fr(22), new Fr(33)])).toEqual( + Fr.fromHexString('0x0014cae968461979aab6d33266a2310ed234d3f6cf4472737c57551db07bd0da'), + ); + }); + + it('chains 256 leaves from zero', () => { + expect(accumulateInboxRollingHash(Fr.ZERO, range(1, 256))).toEqual( + Fr.fromHexString('0x00ea95b96f17b75be03525b35a2a1918b42f03ad8c00a437cf641751825f3992'), + ); + }); + + it('chains from a non-zero start', () => { + expect(accumulateInboxRollingHash(new Fr(0x2a), [new Fr(7), new Fr(8)])).toEqual( + Fr.fromHexString('0x0054d96b8a074a5030a5838972d0a3c04ba47cf5956348c853e02e9566233f65'), + ); + }); + + it('is continuous across segments', () => { + const start = new Fr(0x2a); + const mid = updateInboxRollingHash(start, new Fr(7)); + expect(mid).toEqual(Fr.fromHexString('0x0032a934005556d1b9d22708666ee8b05f91fafad624dd64a6ea878e048e5438')); + // chain(chain(0x2a, [7]), [8]) == chain(0x2a, [7, 8]) + expect(accumulateInboxRollingHash(mid, [new Fr(8)])).toEqual( + accumulateInboxRollingHash(start, [new Fr(7), new Fr(8)]), + ); + }); + + it('returns the start unchanged for an empty list', () => { + const start = new Fr(0x2a); + expect(accumulateInboxRollingHash(start, [])).toEqual(start); + }); +}); diff --git a/yarn-project/stdlib/src/messaging/inbox_rolling_hash.ts b/yarn-project/stdlib/src/messaging/inbox_rolling_hash.ts new file mode 100644 index 000000000000..6a53831ee20d --- /dev/null +++ b/yarn-project/stdlib/src/messaging/inbox_rolling_hash.ts @@ -0,0 +1,20 @@ +import { sha256ToField } from '@aztec/foundation/crypto/sha256'; +import { Fr } from '@aztec/foundation/curves/bn254'; + +/** + * Extends the Inbox rolling-hash chain by a single message leaf, returning the new rolling hash. + * + * Each link is `sha256ToField(prev || leaf)` over the two 32-byte big-endian values, matching the truncated-to-field + * sha256 the L1 Inbox accumulates, today's `inHash` frontier tree, and the noir `accumulate_inbox_rolling_hash` helper. + */ +export function updateInboxRollingHash(prev: Fr, leaf: Fr): Fr { + return sha256ToField([prev.toBuffer(), leaf.toBuffer()]); +} + +/** + * Extends the Inbox rolling-hash chain by a list of message leaves, in order, returning the new rolling hash. + * The genesis rolling hash is `Fr.ZERO`, and an empty list returns `start` unchanged. + */ +export function accumulateInboxRollingHash(start: Fr, leaves: Fr[]): Fr { + return leaves.reduce(updateInboxRollingHash, start); +} diff --git a/yarn-project/stdlib/src/messaging/index.ts b/yarn-project/stdlib/src/messaging/index.ts index 2f9889a6e955..8728940e405a 100644 --- a/yarn-project/stdlib/src/messaging/index.ts +++ b/yarn-project/stdlib/src/messaging/index.ts @@ -1,6 +1,9 @@ export * from './append_l1_to_l2_messages.js'; export * from './in_hash.js'; export * from './inbox_leaf.js'; +export * from './inbox_rolling_hash.js'; +export * from './l1_to_l2_message_bundle.js'; +export * from './l1_to_l2_message_sponge.js'; export * from './l1_to_l2_message.js'; export * from './l1_to_l2_message_source.js'; export * from './l1_actor.js'; diff --git a/yarn-project/stdlib/src/messaging/l1_to_l2_message_bundle.ts b/yarn-project/stdlib/src/messaging/l1_to_l2_message_bundle.ts new file mode 100644 index 000000000000..a35c4c1c9e7c --- /dev/null +++ b/yarn-project/stdlib/src/messaging/l1_to_l2_message_bundle.ts @@ -0,0 +1,70 @@ +import { MAX_L1_TO_L2_MSGS_PER_BLOCK } from '@aztec/constants'; +import { padArrayEnd } from '@aztec/foundation/collection'; +import { Fr } from '@aztec/foundation/curves/bn254'; +import { bufferSchemaFor } from '@aztec/foundation/schemas'; +import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize'; +import { bufferToHex, hexToBuffer } from '@aztec/foundation/string'; + +/** + * A block's L1-to-L2 message bundle: the leaves it inserts into the L1-to-L2 message tree plus the two counts a block + * root needs — one for the (transitionally padded) tree insert, one for the real-count sponge absorb. See the Noir + * `L1ToL2MessageBundle`. Once the tree insert becomes real-count too, `numMsgs === numRealMsgs` and `numRealMsgs` is + * dropped. + */ +export class L1ToL2MessageBundle { + constructor( + /** The message leaves, padded with zeros to `MAX_L1_TO_L2_MSGS_PER_BLOCK`. Kept as a plain array (not a tuple) + * to avoid TS's deep-instantiation limit on the 1024-lane type. */ + public readonly messages: Fr[], + /** Number of leaves inserted into the L1-to-L2 message tree (the padded subtree size, or 0 for an empty block). */ + public readonly numMsgs: number, + /** Number of real (non-padding) messages absorbed into the message sponge. */ + public readonly numRealMsgs: number, + ) {} + + /** An empty bundle: no leaves inserted, nothing absorbed. */ + static empty(): L1ToL2MessageBundle { + return new L1ToL2MessageBundle( + Array.from({ length: MAX_L1_TO_L2_MSGS_PER_BLOCK }, () => Fr.ZERO), + 0, + 0, + ); + } + + toBuffer() { + return serializeToBuffer(this.messages, this.numMsgs, this.numRealMsgs); + } + + toString() { + return bufferToHex(this.toBuffer()); + } + + static fromBuffer(buffer: Buffer | BufferReader) { + const reader = BufferReader.asReader(buffer); + // Array.from (not readArray with the literal cap) keeps the type `Fr[]` and avoids TS's deep-tuple instantiation. + const messages = Array.from({ length: MAX_L1_TO_L2_MSGS_PER_BLOCK }, () => Fr.fromBuffer(reader)); + return new L1ToL2MessageBundle(messages, reader.readNumber(), reader.readNumber()); + } + + static fromString(str: string) { + return L1ToL2MessageBundle.fromBuffer(hexToBuffer(str)); + } + + toJSON() { + return this.toBuffer(); + } + + static get schema() { + return bufferSchemaFor(L1ToL2MessageBundle); + } +} + +/** Pads `messages` to a full subtree and wraps it into a bundle whose tree-insert count is the padded subtree size. */ +export function makeL1ToL2MessageBundle(messages: Fr[]): L1ToL2MessageBundle { + // Explicit `` keeps the result `Fr[]`; padding to the literal cap would otherwise infer a deep tuple. + return new L1ToL2MessageBundle( + padArrayEnd(messages, Fr.ZERO, MAX_L1_TO_L2_MSGS_PER_BLOCK), + MAX_L1_TO_L2_MSGS_PER_BLOCK, + messages.length, + ); +} diff --git a/yarn-project/stdlib/src/messaging/l1_to_l2_message_sponge.ts b/yarn-project/stdlib/src/messaging/l1_to_l2_message_sponge.ts new file mode 100644 index 000000000000..50d4916aecbb --- /dev/null +++ b/yarn-project/stdlib/src/messaging/l1_to_l2_message_sponge.ts @@ -0,0 +1,69 @@ +import { Poseidon2Sponge } from '@aztec/blob-lib/types'; +import { Fr } from '@aztec/foundation/curves/bn254'; +import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize'; +import type { FieldsOf } from '@aztec/foundation/types'; + +/** + * An absorb-only Poseidon2 sponge over L1-to-L2 message leaves. + * + * Mirrors `L1ToL2MessageSponge` in + * `noir-projects/noir-protocol-circuits/crates/rollup-lib/src/abis/l1_to_l2_message_sponge.nr`. Each block of a + * checkpoint absorbs its message bundle into the sponge it inherited from the previous block; the checkpoint root + * recomputes the sponge over the checkpoint's whole message list and asserts the accumulated states are equal. + */ +export class L1ToL2MessageSponge { + constructor( + /** Sponge accumulating the absorbed message leaves. */ + public readonly sponge: Poseidon2Sponge, + /** Number of message leaves absorbed so far. */ + public numAbsorbed: number, + ) {} + + /** A fresh, empty sponge (matching noir's `L1ToL2MessageSponge::new()` / `empty()`, i.e. `Poseidon2Sponge::new(0)`). */ + static empty(): L1ToL2MessageSponge { + return new L1ToL2MessageSponge(Poseidon2Sponge.empty(), 0); + } + + /** Absorb the given message leaves in order. */ + async absorb(leaves: Fr[]) { + await this.sponge.absorb(leaves); + this.numAbsorbed += leaves.length; + } + + clone() { + return L1ToL2MessageSponge.fromBuffer(this.toBuffer()); + } + + static getFields(fields: FieldsOf) { + return [fields.sponge, fields.numAbsorbed] as const; + } + + toBuffer() { + return serializeToBuffer(...L1ToL2MessageSponge.getFields(this)); + } + + static fromBuffer(buffer: Buffer | BufferReader): L1ToL2MessageSponge { + const reader = BufferReader.asReader(buffer); + return new L1ToL2MessageSponge(reader.readObject(Poseidon2Sponge), reader.readNumber()); + } + + toFields(): Fr[] { + return serializeToFields(...L1ToL2MessageSponge.getFields(this)); + } + + static fromFields(fields: Fr[] | FieldReader): L1ToL2MessageSponge { + const reader = FieldReader.asReader(fields); + return new L1ToL2MessageSponge(reader.readObject(Poseidon2Sponge), reader.readField().toNumber()); + } +} + +/** + * Accumulates a fresh message sponge over `leaves`, in order. This is the value the inbox parity proof commits to and + * the checkpoint's block roots reach, starting from the empty sponge. Every leaf passed in is absorbed, so any padding + * the caller includes is part of the accumulated state. + */ +export async function accumulateL1ToL2MessageSponge(leaves: Fr[]): Promise { + const sponge = L1ToL2MessageSponge.empty(); + await sponge.absorb(leaves); + return sponge; +} diff --git a/yarn-project/stdlib/src/parity/inbox_parity_private_inputs.ts b/yarn-project/stdlib/src/parity/inbox_parity_private_inputs.ts new file mode 100644 index 000000000000..70639ab9fa16 --- /dev/null +++ b/yarn-project/stdlib/src/parity/inbox_parity_private_inputs.ts @@ -0,0 +1,140 @@ +import { INBOX_PARITY_SIZE_LARGE, INBOX_PARITY_SIZE_MEDIUM, INBOX_PARITY_SIZE_SMALL } from '@aztec/constants'; +import { padArrayEnd } from '@aztec/foundation/collection'; +import { Fr } from '@aztec/foundation/curves/bn254'; +import { bufferSchemaFor } from '@aztec/foundation/schemas'; +import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize'; +import { bufferToHex, hexToBuffer } from '@aztec/foundation/string'; + +import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js'; + +/** The InboxParity size ladder, ascending. One VK per size; the prover proves the smallest that fits. */ +export const INBOX_PARITY_SIZES = [INBOX_PARITY_SIZE_SMALL, INBOX_PARITY_SIZE_MEDIUM, INBOX_PARITY_SIZE_LARGE] as const; + +/** A valid InboxParity ladder size. */ +export type InboxParitySize = (typeof INBOX_PARITY_SIZES)[number]; + +/** + * Picks the smallest ladder size that can hold `numMessages` messages. + * @throws if `numMessages` exceeds the largest rung. + */ +export function pickInboxParitySize(numMessages: number): InboxParitySize { + const size = INBOX_PARITY_SIZES.find(s => numMessages <= s); + if (size === undefined) { + throw new Error( + `Cannot fit ${numMessages} L1-to-L2 messages into any InboxParity size (max ${INBOX_PARITY_SIZE_LARGE})`, + ); + } + return size; +} + +/** + * Private inputs for one `InboxParity` proof (S = `size`). The prover produces exactly one per checkpoint, sized + * by the checkpoint's message count via {@link pickInboxParitySize}. + */ +export class InboxParityPrivateInputs { + constructor( + /** Ladder size S: the length of `messages` and the circuit variant to prove ({@link INBOX_PARITY_SIZES}). */ + public readonly size: InboxParitySize, + /** The checkpoint's L1-to-L2 messages, padded with zeros to `size`; the first `numMessages` are real. */ + public readonly messages: Fr[], + /** Number of real (non-padding) messages in `messages`. */ + public readonly numMessages: number, + /** Inbox rolling hash before this checkpoint's messages (the previous checkpoint's end; genesis is zero). */ + public readonly startRollingHash: Fr, + /** Message-bundle sponge before this checkpoint's messages (empty at checkpoint start). */ + public readonly startSponge: L1ToL2MessageSponge, + /** The L1 `in_hash` (sha256 frontier root), passed through unconstrained by the circuit. */ + public readonly inHash: Fr, + /** Root of the VK tree. */ + public readonly vkTreeRoot: Fr, + /** Prover identity committed to by the circuit, for sybil protection. */ + public readonly proverId: Fr, + ) { + if (messages.length !== size) { + throw new Error(`InboxParity messages length (${messages.length}) must equal size (${size})`); + } + } + + /** + * Builds the inputs from a checkpoint's real messages, sizing the circuit by the message count and padding the + * message array out to that size. + */ + static fromMessages( + messages: Fr[], + startRollingHash: Fr, + startSponge: L1ToL2MessageSponge, + inHash: Fr, + vkTreeRoot: Fr, + proverId: Fr, + ): InboxParityPrivateInputs { + const size = pickInboxParitySize(messages.length); + // Explicit `` keeps the result `Fr[]`; padding to the union-literal `size` would infer a deep tuple. + return new InboxParityPrivateInputs( + size, + padArrayEnd(messages, Fr.ZERO, size), + messages.length, + startRollingHash, + startSponge, + inHash, + vkTreeRoot, + proverId, + ); + } + + /** Serializes the inputs to a buffer. */ + toBuffer() { + return serializeToBuffer( + new Fr(this.size), + this.messages, + new Fr(this.numMessages), + this.startRollingHash, + this.startSponge, + this.inHash, + this.vkTreeRoot, + this.proverId, + ); + } + + /** Serializes the inputs to a hex string. */ + toString() { + return bufferToHex(this.toBuffer()); + } + + /** + * Deserializes the inputs from a buffer. + * @param buffer - The buffer to deserialize from. + */ + static fromBuffer(buffer: Buffer | BufferReader) { + const reader = BufferReader.asReader(buffer); + const size = Fr.fromBuffer(reader).toNumber() as InboxParitySize; + // Array.from keeps the type `Fr[]`; readArray with the union-literal `size` would infer a deep tuple. + const messages = Array.from({ length: size }, () => Fr.fromBuffer(reader)); + return new InboxParityPrivateInputs( + size, + messages, + Fr.fromBuffer(reader).toNumber(), + Fr.fromBuffer(reader), + reader.readObject(L1ToL2MessageSponge), + Fr.fromBuffer(reader), + Fr.fromBuffer(reader), + Fr.fromBuffer(reader), + ); + } + + /** + * Deserializes the inputs from a hex string. + * @param str - The hex string to deserialize from. + */ + static fromString(str: string) { + return InboxParityPrivateInputs.fromBuffer(hexToBuffer(str)); + } + + /** Returns a buffer representation for JSON serialization. */ + toJSON() { + return this.toBuffer(); + } + + static get schema() { + return bufferSchemaFor(InboxParityPrivateInputs); + } +} diff --git a/yarn-project/stdlib/src/parity/index.ts b/yarn-project/stdlib/src/parity/index.ts index c527165dbcb3..0a043655c73e 100644 --- a/yarn-project/stdlib/src/parity/index.ts +++ b/yarn-project/stdlib/src/parity/index.ts @@ -1,3 +1,2 @@ -export * from './parity_base_private_inputs.js'; +export * from './inbox_parity_private_inputs.js'; export * from './parity_public_inputs.js'; -export * from './parity_root_private_inputs.js'; diff --git a/yarn-project/stdlib/src/parity/parity_base_private_inputs.test.ts b/yarn-project/stdlib/src/parity/parity_base_private_inputs.test.ts deleted file mode 100644 index a0f6954e5967..000000000000 --- a/yarn-project/stdlib/src/parity/parity_base_private_inputs.test.ts +++ /dev/null @@ -1,18 +0,0 @@ -import { makeParityBasePrivateInputs } from '../tests/factories.js'; -import { ParityBasePrivateInputs } from './parity_base_private_inputs.js'; - -describe('ParityBasePrivateInputs', () => { - it(`serializes a ParityBasePrivateInputs to buffer and deserializes it back`, () => { - const expected = makeParityBasePrivateInputs(); - const buffer = expected.toBuffer(); - const res = ParityBasePrivateInputs.fromBuffer(buffer); - expect(res).toEqual(expected); - }); - - it(`serializes a ParityBasePrivateInputs to hex string and deserializes it back`, () => { - const expected = makeParityBasePrivateInputs(); - const str = expected.toString(); - const res = ParityBasePrivateInputs.fromString(str); - expect(res).toEqual(expected); - }); -}); diff --git a/yarn-project/stdlib/src/parity/parity_base_private_inputs.ts b/yarn-project/stdlib/src/parity/parity_base_private_inputs.ts deleted file mode 100644 index 0c3bf62ac2f9..000000000000 --- a/yarn-project/stdlib/src/parity/parity_base_private_inputs.ts +++ /dev/null @@ -1,71 +0,0 @@ -import { NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, NUM_MSGS_PER_BASE_PARITY } from '@aztec/constants'; -import { Fr } from '@aztec/foundation/curves/bn254'; -import { bufferSchemaFor } from '@aztec/foundation/schemas'; -import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize'; -import { bufferToHex, hexToBuffer } from '@aztec/foundation/string'; - -export class ParityBasePrivateInputs { - constructor( - /** Aggregated proof of all the parity circuit iterations. */ - public readonly msgs: Tuple, - /** Root of the VK tree */ - public readonly vkTreeRoot: Fr, - /** Prover identity committed to by the circuit, for sybil protection. */ - public readonly proverId: Fr, - ) {} - - public static fromSlice(array: Fr[], index: number, vkTreeRoot: Fr, proverId: Fr): ParityBasePrivateInputs { - // Can't use Tuple due to length - if (array.length !== NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP) { - throw new Error( - `Msgs array length must be NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP=${NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP}`, - ); - } - const start = index * NUM_MSGS_PER_BASE_PARITY; - const end = start + NUM_MSGS_PER_BASE_PARITY; - const msgs = array.slice(start, end); - return new ParityBasePrivateInputs(msgs as Tuple, vkTreeRoot, proverId); - } - - /** Serializes the inputs to a buffer. */ - toBuffer() { - return serializeToBuffer(this.msgs, this.vkTreeRoot, this.proverId); - } - - /** Serializes the inputs to a hex string. */ - toString() { - return bufferToHex(this.toBuffer()); - } - - /** - * Deserializes the inputs from a buffer. - * @param buffer - The buffer to deserialize from. - */ - static fromBuffer(buffer: Buffer | BufferReader) { - const reader = BufferReader.asReader(buffer); - return new ParityBasePrivateInputs( - reader.readArray(NUM_MSGS_PER_BASE_PARITY, Fr), - Fr.fromBuffer(reader), - Fr.fromBuffer(reader), - ); - } - - /** - * Deserializes the inputs from a hex string. - * @param str - The hex string to deserialize from. - * @returns - The deserialized inputs. - */ - static fromString(str: string) { - return ParityBasePrivateInputs.fromBuffer(hexToBuffer(str)); - } - - /** Returns a buffer representation for JSON serialization. */ - toJSON() { - return this.toBuffer(); - } - - /** Creates an instance from a hex string. */ - static get schema() { - return bufferSchemaFor(ParityBasePrivateInputs); - } -} diff --git a/yarn-project/stdlib/src/parity/parity_public_inputs.ts b/yarn-project/stdlib/src/parity/parity_public_inputs.ts index b8f0feaff2db..40a9d12b48fd 100644 --- a/yarn-project/stdlib/src/parity/parity_public_inputs.ts +++ b/yarn-project/stdlib/src/parity/parity_public_inputs.ts @@ -4,19 +4,32 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize'; import { bufferToHex, hexToBuffer } from '@aztec/foundation/string'; import type { FieldsOf } from '@aztec/foundation/types'; +import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js'; + export class ParityPublicInputs { constructor( - /** Root of the SHA256 tree. */ - public shaRoot: Fr, - /** Root of the converted tree. */ - public convertedRoot: Fr, + /** + * The L1 `in_hash` (sha256 frontier root of the checkpoint's messages). Unconstrained pass-through: InboxParity + * echoes the value the prover supplies; it stays the authoritative L1 check until the Fast Inbox flip. + */ + public inHash: Fr, + /** Inbox rolling hash before absorbing this checkpoint's messages. */ + public startRollingHash: Fr, + /** Inbox rolling hash after absorbing the `numMsgs` real messages. */ + public endRollingHash: Fr, + /** Message-bundle sponge before absorbing this checkpoint's messages (empty at checkpoint start). */ + public startSponge: L1ToL2MessageSponge, + /** Message-bundle sponge after absorbing the `numMsgs` real messages. */ + public endSponge: L1ToL2MessageSponge, + /** Number of real (non-padding) messages absorbed into the rolling hash and the sponge. */ + public numMsgs: number, /** Root of the VK tree */ public vkTreeRoot: Fr, /** Prover identity committed to by the circuit, for sybil protection. */ public proverId: Fr, ) { - if (shaRoot.toBuffer()[0] != 0) { - throw new Error(`shaRoot buffer must be 31 bytes. Got 32 bytes`); + if (inHash.toBuffer()[0] != 0) { + throw new Error(`inHash buffer must be 31 bytes. Got 32 bytes`); } } @@ -25,7 +38,16 @@ export class ParityPublicInputs { * @returns The inputs serialized to a buffer. */ toBuffer() { - return serializeToBuffer(...ParityPublicInputs.getFields(this)); + return serializeToBuffer( + this.inHash, + this.startRollingHash, + this.endRollingHash, + this.startSponge, + this.endSponge, + new Fr(this.numMsgs), + this.vkTreeRoot, + this.proverId, + ); } /** @@ -56,7 +78,16 @@ export class ParityPublicInputs { * @returns The instance fields. */ static getFields(fields: FieldsOf) { - return [fields.shaRoot, fields.convertedRoot, fields.vkTreeRoot, fields.proverId] as const; + return [ + fields.inHash, + fields.startRollingHash, + fields.endRollingHash, + fields.startSponge, + fields.endSponge, + fields.numMsgs, + fields.vkTreeRoot, + fields.proverId, + ] as const; } /** @@ -69,6 +100,10 @@ export class ParityPublicInputs { return new ParityPublicInputs( reader.readObject(Fr), reader.readObject(Fr), + reader.readObject(Fr), + reader.readObject(L1ToL2MessageSponge), + reader.readObject(L1ToL2MessageSponge), + Fr.fromBuffer(reader).toNumber(), Fr.fromBuffer(reader), Fr.fromBuffer(reader), ); diff --git a/yarn-project/stdlib/src/parity/parity_root_private_inputs.test.ts b/yarn-project/stdlib/src/parity/parity_root_private_inputs.test.ts deleted file mode 100644 index 649e816c950e..000000000000 --- a/yarn-project/stdlib/src/parity/parity_root_private_inputs.test.ts +++ /dev/null @@ -1,18 +0,0 @@ -import { makeParityRootPrivateInputs } from '../tests/factories.js'; -import { ParityRootPrivateInputs } from './parity_root_private_inputs.js'; - -describe('ParityRootPrivateInputs', () => { - it(`serializes a ParityRootPrivateInputs to buffer and deserializes it back`, () => { - const expected = makeParityRootPrivateInputs(); - const buffer = expected.toBuffer(); - const res = ParityRootPrivateInputs.fromBuffer(buffer); - expect(res).toEqual(expected); - }); - - it(`serializes a ParityRootPrivateInputs to hex string and deserializes it back`, () => { - const expected = makeParityRootPrivateInputs(); - const str = expected.toString(); - const res = ParityRootPrivateInputs.fromString(str); - expect(res).toEqual(expected); - }); -}); diff --git a/yarn-project/stdlib/src/parity/parity_root_private_inputs.ts b/yarn-project/stdlib/src/parity/parity_root_private_inputs.ts deleted file mode 100644 index 157eb5204a10..000000000000 --- a/yarn-project/stdlib/src/parity/parity_root_private_inputs.ts +++ /dev/null @@ -1,64 +0,0 @@ -import { NUM_BASE_PARITY_PER_ROOT_PARITY } from '@aztec/constants'; -import { makeTuple } from '@aztec/foundation/array'; -import { bufferSchemaFor } from '@aztec/foundation/schemas'; -import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/serialize'; -import { bufferToHex, hexToBuffer } from '@aztec/foundation/string'; - -import { ProofData, type UltraHonkProofData } from '../proofs/proof_data.js'; -import { ParityPublicInputs } from './parity_public_inputs.js'; - -export type ParityBaseProofData = UltraHonkProofData; - -export class ParityRootPrivateInputs { - constructor( - /** Public inputs of the parity base circuits and their proofs and vk data. */ - public readonly children: Tuple, - ) {} - - /** - * Serializes the inputs to a buffer. - * @returns The inputs serialized to a buffer. - */ - toBuffer() { - return serializeToBuffer(this.children); - } - - /** - * Serializes the inputs to a hex string. - * @returns The instance serialized to a hex string. - */ - toString() { - return bufferToHex(this.toBuffer()); - } - - /** - * Deserializes the inputs from a buffer. - * @param buffer - The buffer to deserialize from. - * @returns A new ParityRootPrivateInputs instance. - */ - static fromBuffer(buffer: Buffer | BufferReader) { - const reader = BufferReader.asReader(buffer); - return new ParityRootPrivateInputs( - makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, () => ProofData.fromBuffer(reader, ParityPublicInputs)), - ); - } - - /** - * Deserializes the inputs from a hex string. - * @param str - A hex string to deserialize from. - * @returns A new ParityRootPrivateInputs instance. - */ - static fromString(str: string) { - return ParityRootPrivateInputs.fromBuffer(hexToBuffer(str)); - } - - /** Returns a buffer representation for JSON serialization. */ - toJSON() { - return this.toBuffer(); - } - - /** Creates an instance from a hex string. */ - static get schema() { - return bufferSchemaFor(ParityRootPrivateInputs); - } -} diff --git a/yarn-project/stdlib/src/proofs/proving_request_type.ts b/yarn-project/stdlib/src/proofs/proving_request_type.ts index d7517c61cd56..8ea73232fa1b 100644 --- a/yarn-project/stdlib/src/proofs/proving_request_type.ts +++ b/yarn-project/stdlib/src/proofs/proving_request_type.ts @@ -10,6 +10,7 @@ export enum ProvingRequestType { BLOCK_ROOT_EMPTY_TX_FIRST_ROLLUP, BLOCK_ROOT_ROLLUP, BLOCK_ROOT_SINGLE_TX_ROLLUP, + BLOCK_ROOT_MSGS_ONLY_ROLLUP, BLOCK_MERGE_ROLLUP, CHECKPOINT_ROOT_ROLLUP, CHECKPOINT_ROOT_SINGLE_BLOCK_ROLLUP, @@ -17,6 +18,5 @@ export enum ProvingRequestType { CHECKPOINT_MERGE_ROLLUP, ROOT_ROLLUP, - PARITY_BASE, - PARITY_ROOT, + INBOX_PARITY, } diff --git a/yarn-project/stdlib/src/rollup/block_constant_data.ts b/yarn-project/stdlib/src/rollup/block_constant_data.ts index 60979da2a73f..fd7e7f5c5f20 100644 --- a/yarn-project/stdlib/src/rollup/block_constant_data.ts +++ b/yarn-project/stdlib/src/rollup/block_constant_data.ts @@ -13,10 +13,10 @@ export class BlockConstantData { /** Archive tree snapshot at the very beginning of the entire rollup. */ public lastArchive: AppendOnlyTreeSnapshot, /** - * L1-to-L2 message tree snapshot after this block lands. - * For the first block in a checkpoint, this should be the snapshot after inserting the new l1-to-l2 message subtree - * into the last l1-to-l2 tree snapshot in `last_archive`. - * For subsequent blocks, this should match the snapshot of the previous block. + * L1-to-L2 message tree snapshot after this block's own message bundle has been inserted. The AVM validates this + * block's l1-to-l2 message read requests against it, so a tx in this block can read the messages this block + * inserts (same-block consumption). Every block-root variant that carries txs asserts this equals its computed + * post-bundle root, whether or not the block is the first in its checkpoint. */ public l1ToL2TreeSnapshot: AppendOnlyTreeSnapshot, /** Root of the verification key tree. */ diff --git a/yarn-project/stdlib/src/rollup/block_rollup_public_inputs.ts b/yarn-project/stdlib/src/rollup/block_rollup_public_inputs.ts index 12b6b1926e10..e597a2261ef2 100644 --- a/yarn-project/stdlib/src/rollup/block_rollup_public_inputs.ts +++ b/yarn-project/stdlib/src/rollup/block_rollup_public_inputs.ts @@ -4,6 +4,7 @@ import { bufferSchemaFor } from '@aztec/foundation/schemas'; import { BufferReader, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize'; import { bufferToHex, hexToBuffer } from '@aztec/foundation/string'; +import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js'; import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js'; import { StateReference } from '../tx/state_reference.js'; import type { UInt64 } from '../types/shared.js'; @@ -53,9 +54,19 @@ export class BlockRollupPublicInputs { */ public blockHeadersHash: Fr, /** - * SHA256 hash of l1 to l2 messages. + * Whether this block range starts at the first block of its checkpoint. Only the first block root sets this true; + * merges propagate it from the left rollup. */ - public inHash: Fr, + public isFirstBlock: boolean, + /** + * Message-bundle sponge threaded across the checkpoint's blocks, before this block range absorbs its bundle. + */ + public startMsgSponge: L1ToL2MessageSponge, + /** + * Message-bundle sponge after this block range absorbs its bundle. The checkpoint root asserts the final value + * matches the parity root's sponge over the same (padded) message list. + */ + public endMsgSponge: L1ToL2MessageSponge, /** * SHA256 hash of L2 to L1 messages created in this block range. */ @@ -82,7 +93,9 @@ export class BlockRollupPublicInputs { reader.readObject(SpongeBlob), reader.readUInt64(), Fr.fromBuffer(reader), - Fr.fromBuffer(reader), + reader.readBoolean(), + reader.readObject(L1ToL2MessageSponge), + reader.readObject(L1ToL2MessageSponge), Fr.fromBuffer(reader), Fr.fromBuffer(reader), Fr.fromBuffer(reader), @@ -100,7 +113,9 @@ export class BlockRollupPublicInputs { this.endSpongeBlob, bigintToUInt64BE(this.timestamp), this.blockHeadersHash, - this.inHash, + this.isFirstBlock, + this.startMsgSponge, + this.endMsgSponge, this.outHash, this.accumulatedFees, this.accumulatedManaUsed, @@ -124,7 +139,9 @@ export class BlockRollupPublicInputs { previousArchiveRoot: this.previousArchive.root.toString(), newArchiveRoot: this.newArchive.root.toString(), blockHeadersHash: this.blockHeadersHash.toString(), - inHash: this.inHash.toString(), + isFirstBlock: this.isFirstBlock, + startMsgSpongeNumAbsorbed: this.startMsgSponge.numAbsorbed, + endMsgSpongeNumAbsorbed: this.endMsgSponge.numAbsorbed, outHash: this.outHash.toString(), timestamp: this.timestamp.toString(), accumulatedFees: this.accumulatedFees.toString(), diff --git a/yarn-project/stdlib/src/rollup/block_root_rollup_private_inputs.ts b/yarn-project/stdlib/src/rollup/block_root_rollup_private_inputs.ts index 19a99769dac9..206572d4a7c6 100644 --- a/yarn-project/stdlib/src/rollup/block_root_rollup_private_inputs.ts +++ b/yarn-project/stdlib/src/rollup/block_root_rollup_private_inputs.ts @@ -1,11 +1,13 @@ -import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH } from '@aztec/constants'; +import { SpongeBlob } from '@aztec/blob-lib/types'; +import { ARCHIVE_HEIGHT, L1_TO_L2_MSG_TREE_HEIGHT } from '@aztec/constants'; import { Fr } from '@aztec/foundation/curves/bn254'; import { bufferSchemaFor } from '@aztec/foundation/schemas'; import { BufferReader, type Tuple, bigintToUInt64BE, serializeToBuffer } from '@aztec/foundation/serialize'; import type { FieldsOf } from '@aztec/foundation/types'; -import { ParityPublicInputs } from '../parity/parity_public_inputs.js'; -import { ProofData, type RollupHonkProofData, type UltraHonkProofData } from '../proofs/proof_data.js'; +import { L1ToL2MessageBundle } from '../messaging/l1_to_l2_message_bundle.js'; +import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js'; +import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js'; import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js'; import { StateReference } from '../tx/state_reference.js'; import type { UInt64 } from '../types/shared.js'; @@ -14,22 +16,22 @@ import { TxRollupPublicInputs } from './tx_rollup_public_inputs.js'; export class BlockRootFirstRollupPrivateInputs { constructor( - /** - * The original and converted roots of the L1 to L2 messages subtrees. - */ - public l1ToL2Roots: UltraHonkProofData, /** * The previous rollup proof data from base or merge rollup circuits. */ public previousRollups: [RollupHonkProofData, RollupHonkProofData], + /** + * L1-to-L2 message bundle inserted by this block. + */ + public messageBundle: L1ToL2MessageBundle, /** * The l1 to l2 message tree snapshot immediately before this block. */ public previousL1ToL2: AppendOnlyTreeSnapshot, /** - * Hint for inserting the new l1 to l2 message subtree root into `previousL1ToL2`. + * Frontier hint for appending the message bundle to `previousL1ToL2`. */ - public newL1ToL2MessageSubtreeRootSiblingPath: Tuple, + public l1ToL2MessageFrontierHint: Tuple, /** * Hint for inserting the new block hash to the last archive. */ @@ -42,25 +44,31 @@ export class BlockRootFirstRollupPrivateInputs { static getFields(fields: FieldsOf) { return [ - fields.l1ToL2Roots, fields.previousRollups, + fields.messageBundle, fields.previousL1ToL2, - fields.newL1ToL2MessageSubtreeRootSiblingPath, + fields.l1ToL2MessageFrontierHint, fields.newArchiveSiblingPath, ] as const; } toBuffer() { - return serializeToBuffer(...BlockRootFirstRollupPrivateInputs.getFields(this)); + return serializeToBuffer( + this.previousRollups, + this.messageBundle, + this.previousL1ToL2, + this.l1ToL2MessageFrontierHint, + this.newArchiveSiblingPath, + ); } static fromBuffer(buffer: Buffer | BufferReader) { const reader = BufferReader.asReader(buffer); return new BlockRootFirstRollupPrivateInputs( - ProofData.fromBuffer(reader, ParityPublicInputs), [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)], + reader.readObject(L1ToL2MessageBundle), AppendOnlyTreeSnapshot.fromBuffer(reader), - reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr), + reader.readArray(L1_TO_L2_MSG_TREE_HEIGHT, Fr), reader.readArray(ARCHIVE_HEIGHT, Fr), ); } @@ -76,22 +84,22 @@ export class BlockRootFirstRollupPrivateInputs { export class BlockRootSingleTxFirstRollupPrivateInputs { constructor( - /** - * The original and converted roots of the L1 to L2 messages subtrees. - */ - public l1ToL2Roots: UltraHonkProofData, /** * The previous rollup proof data from base or merge rollup circuits. */ public previousRollup: RollupHonkProofData, + /** + * L1-to-L2 message bundle inserted by this block. + */ + public messageBundle: L1ToL2MessageBundle, /** * The l1 to l2 message tree snapshot immediately before this block. */ public previousL1ToL2: AppendOnlyTreeSnapshot, /** - * Hint for inserting the new l1 to l2 message subtree root. + * Frontier hint for appending the message bundle to `previousL1ToL2`. */ - public newL1ToL2MessageSubtreeRootSiblingPath: Tuple, + public l1ToL2MessageFrontierHint: Tuple, /** * Hint for inserting the new block hash to the last archive. */ @@ -106,25 +114,31 @@ export class BlockRootSingleTxFirstRollupPrivateInputs { static getFields(fields: FieldsOf) { return [ - fields.l1ToL2Roots, fields.previousRollup, + fields.messageBundle, fields.previousL1ToL2, - fields.newL1ToL2MessageSubtreeRootSiblingPath, + fields.l1ToL2MessageFrontierHint, fields.newArchiveSiblingPath, ] as const; } toBuffer() { - return serializeToBuffer(...BlockRootSingleTxFirstRollupPrivateInputs.getFields(this)); + return serializeToBuffer( + this.previousRollup, + this.messageBundle, + this.previousL1ToL2, + this.l1ToL2MessageFrontierHint, + this.newArchiveSiblingPath, + ); } static fromBuffer(buffer: Buffer | BufferReader) { const reader = BufferReader.asReader(buffer); return new BlockRootSingleTxFirstRollupPrivateInputs( - ProofData.fromBuffer(reader, ParityPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs), + reader.readObject(L1ToL2MessageBundle), AppendOnlyTreeSnapshot.fromBuffer(reader), - reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr), + reader.readArray(L1_TO_L2_MSG_TREE_HEIGHT, Fr), reader.readArray(ARCHIVE_HEIGHT, Fr), ); } @@ -140,10 +154,6 @@ export class BlockRootSingleTxFirstRollupPrivateInputs { export class BlockRootEmptyTxFirstRollupPrivateInputs { constructor( - /** - * The original and converted roots of the L1 to L2 messages subtrees. - */ - public l1ToL2Roots: UltraHonkProofData, /** * The archive after applying the previous block. */ @@ -161,9 +171,13 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs { */ public timestamp: UInt64, /** - * Hint for inserting the new l1 to l2 message subtree root. + * L1-to-L2 message bundle inserted by this block. + */ + public messageBundle: L1ToL2MessageBundle, + /** + * Frontier hint for appending the message bundle to the previous state's l1 to l2 message tree. */ - public newL1ToL2MessageSubtreeRootSiblingPath: Tuple, + public l1ToL2MessageFrontierHint: Tuple, /** * Hint for inserting the new block hash to the last archive. */ @@ -176,37 +190,37 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs { static getFields(fields: FieldsOf) { return [ - fields.l1ToL2Roots, fields.previousArchive, fields.previousState, fields.constants, fields.timestamp, - fields.newL1ToL2MessageSubtreeRootSiblingPath, + fields.messageBundle, + fields.l1ToL2MessageFrontierHint, fields.newArchiveSiblingPath, ] as const; } toBuffer() { - return serializeToBuffer([ - this.l1ToL2Roots, + return serializeToBuffer( this.previousArchive, this.previousState, this.constants, bigintToUInt64BE(this.timestamp), - this.newL1ToL2MessageSubtreeRootSiblingPath, + this.messageBundle, + this.l1ToL2MessageFrontierHint, this.newArchiveSiblingPath, - ]); + ); } static fromBuffer(buffer: Buffer | BufferReader) { const reader = BufferReader.asReader(buffer); return new BlockRootEmptyTxFirstRollupPrivateInputs( - ProofData.fromBuffer(reader, ParityPublicInputs), AppendOnlyTreeSnapshot.fromBuffer(reader), StateReference.fromBuffer(reader), CheckpointConstantData.fromBuffer(reader), reader.readUInt64(), - reader.readArray(L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, Fr), + reader.readObject(L1ToL2MessageBundle), + reader.readArray(L1_TO_L2_MSG_TREE_HEIGHT, Fr), reader.readArray(ARCHIVE_HEIGHT, Fr), ); } @@ -220,12 +234,126 @@ export class BlockRootEmptyTxFirstRollupPrivateInputs { } } +export class BlockRootMsgsOnlyRollupPrivateInputs { + constructor( + /** + * The archive after applying the previous block. + */ + public previousArchive: AppendOnlyTreeSnapshot, + /** + * The state reference of the previous block. + */ + public previousState: StateReference, + /** + * The constants of the checkpoint. + */ + public constants: CheckpointConstantData, + /** + * The timestamp of this block. + */ + public timestamp: UInt64, + /** + * Sponge blob inherited from the previous block (checked against its `endSpongeBlob` in the merge/checkpoint root). + */ + public startSpongeBlob: SpongeBlob, + /** + * Message sponge inherited from the previous block (checked against its `endMsgSponge` in the merge/checkpoint root). + */ + public startMsgSponge: L1ToL2MessageSponge, + /** + * L1-to-L2 message bundle inserted by this block. + */ + public messageBundle: L1ToL2MessageBundle, + /** + * Frontier hint for appending the message bundle to the previous state's l1 to l2 message tree. + */ + public l1ToL2MessageFrontierHint: Tuple, + /** + * Hint for inserting the new block hash to the last archive. + */ + public newArchiveSiblingPath: Tuple, + ) {} + + static from(fields: FieldsOf) { + return new BlockRootMsgsOnlyRollupPrivateInputs(...BlockRootMsgsOnlyRollupPrivateInputs.getFields(fields)); + } + + static getFields(fields: FieldsOf) { + return [ + fields.previousArchive, + fields.previousState, + fields.constants, + fields.timestamp, + fields.startSpongeBlob, + fields.startMsgSponge, + fields.messageBundle, + fields.l1ToL2MessageFrontierHint, + fields.newArchiveSiblingPath, + ] as const; + } + + toBuffer() { + return serializeToBuffer( + this.previousArchive, + this.previousState, + this.constants, + bigintToUInt64BE(this.timestamp), + this.startSpongeBlob, + this.startMsgSponge, + this.messageBundle, + this.l1ToL2MessageFrontierHint, + this.newArchiveSiblingPath, + ); + } + + static fromBuffer(buffer: Buffer | BufferReader) { + const reader = BufferReader.asReader(buffer); + return new BlockRootMsgsOnlyRollupPrivateInputs( + AppendOnlyTreeSnapshot.fromBuffer(reader), + StateReference.fromBuffer(reader), + CheckpointConstantData.fromBuffer(reader), + reader.readUInt64(), + reader.readObject(SpongeBlob), + reader.readObject(L1ToL2MessageSponge), + reader.readObject(L1ToL2MessageBundle), + reader.readArray(L1_TO_L2_MSG_TREE_HEIGHT, Fr), + reader.readArray(ARCHIVE_HEIGHT, Fr), + ); + } + + toJSON() { + return this.toBuffer(); + } + + static get schema() { + return bufferSchemaFor(BlockRootMsgsOnlyRollupPrivateInputs); + } +} + export class BlockRootRollupPrivateInputs { constructor( /** * The previous rollup proof data from base or merge rollup circuits. */ public previousRollups: [RollupHonkProofData, RollupHonkProofData], + /** + * L1-to-L2 message bundle inserted by this block. + */ + public messageBundle: L1ToL2MessageBundle, + /** + * The l1 to l2 message tree snapshot this block builds on (the previous block's post-insertion snapshot). Pinned by + * block-merge continuity to the previous block's end state; the circuit appends this block's bundle on top and + * asserts the tx constants carry the resulting post-bundle snapshot. + */ + public previousL1ToL2: AppendOnlyTreeSnapshot, + /** + * Message sponge inherited from the previous block (checked against its `endMsgSponge` in the merge/checkpoint root). + */ + public startMsgSponge: L1ToL2MessageSponge, + /** + * Frontier hint for appending the message bundle to `previousL1ToL2`. + */ + public l1ToL2MessageFrontierHint: Tuple, /** * Hint for inserting the new block hash to the last archive. */ @@ -237,17 +365,35 @@ export class BlockRootRollupPrivateInputs { } static getFields(fields: FieldsOf) { - return [fields.previousRollups, fields.newArchiveSiblingPath] as const; + return [ + fields.previousRollups, + fields.messageBundle, + fields.previousL1ToL2, + fields.startMsgSponge, + fields.l1ToL2MessageFrontierHint, + fields.newArchiveSiblingPath, + ] as const; } toBuffer() { - return serializeToBuffer(...BlockRootRollupPrivateInputs.getFields(this)); + return serializeToBuffer( + this.previousRollups, + this.messageBundle, + this.previousL1ToL2, + this.startMsgSponge, + this.l1ToL2MessageFrontierHint, + this.newArchiveSiblingPath, + ); } static fromBuffer(buffer: Buffer | BufferReader) { const reader = BufferReader.asReader(buffer); return new BlockRootRollupPrivateInputs( [ProofData.fromBuffer(reader, TxRollupPublicInputs), ProofData.fromBuffer(reader, TxRollupPublicInputs)], + reader.readObject(L1ToL2MessageBundle), + AppendOnlyTreeSnapshot.fromBuffer(reader), + reader.readObject(L1ToL2MessageSponge), + reader.readArray(L1_TO_L2_MSG_TREE_HEIGHT, Fr), reader.readArray(ARCHIVE_HEIGHT, Fr), ); } @@ -267,6 +413,24 @@ export class BlockRootSingleTxRollupPrivateInputs { * The previous rollup proof data from base or merge rollup circuits. */ public previousRollup: RollupHonkProofData, + /** + * L1-to-L2 message bundle inserted by this block. + */ + public messageBundle: L1ToL2MessageBundle, + /** + * The l1 to l2 message tree snapshot this block builds on (the previous block's post-insertion snapshot). Pinned by + * block-merge continuity to the previous block's end state; the circuit appends this block's bundle on top and + * asserts the tx constants carry the resulting post-bundle snapshot. + */ + public previousL1ToL2: AppendOnlyTreeSnapshot, + /** + * Message sponge inherited from the previous block (checked against its `endMsgSponge` in the merge/checkpoint root). + */ + public startMsgSponge: L1ToL2MessageSponge, + /** + * Frontier hint for appending the message bundle to `previousL1ToL2`. + */ + public l1ToL2MessageFrontierHint: Tuple, /** * Hint for inserting the new block hash to the last archive. */ @@ -278,17 +442,35 @@ export class BlockRootSingleTxRollupPrivateInputs { } static getFields(fields: FieldsOf) { - return [fields.previousRollup, fields.newArchiveSiblingPath] as const; + return [ + fields.previousRollup, + fields.messageBundle, + fields.previousL1ToL2, + fields.startMsgSponge, + fields.l1ToL2MessageFrontierHint, + fields.newArchiveSiblingPath, + ] as const; } toBuffer() { - return serializeToBuffer(...BlockRootSingleTxRollupPrivateInputs.getFields(this)); + return serializeToBuffer( + this.previousRollup, + this.messageBundle, + this.previousL1ToL2, + this.startMsgSponge, + this.l1ToL2MessageFrontierHint, + this.newArchiveSiblingPath, + ); } static fromBuffer(buffer: Buffer | BufferReader) { const reader = BufferReader.asReader(buffer); return new BlockRootSingleTxRollupPrivateInputs( ProofData.fromBuffer(reader, TxRollupPublicInputs), + reader.readObject(L1ToL2MessageBundle), + AppendOnlyTreeSnapshot.fromBuffer(reader), + reader.readObject(L1ToL2MessageSponge), + reader.readArray(L1_TO_L2_MSG_TREE_HEIGHT, Fr), reader.readArray(ARCHIVE_HEIGHT, Fr), ); } diff --git a/yarn-project/stdlib/src/rollup/checkpoint_header.test.ts b/yarn-project/stdlib/src/rollup/checkpoint_header.test.ts index 2748572da831..5c29c4ce8017 100644 --- a/yarn-project/stdlib/src/rollup/checkpoint_header.test.ts +++ b/yarn-project/stdlib/src/rollup/checkpoint_header.test.ts @@ -22,7 +22,7 @@ describe('CheckpointHeader', () => { const header = CheckpointHeader.empty(); const hash = header.hash().toString(); - expect(hash).toMatchInlineSnapshot('"0x002e384af86a480f952aa16443fd29646a9063865e62d7c403fc7ed697bb7712"'); + expect(hash).toMatchInlineSnapshot(`"0x0008c3e5bbea4fba57201a69d4bf70a0d255df921fdef4924c22da087f9338c2"`); // Run with AZTEC_GENERATE_TEST_DATA=1 to update noir test data updateInlineTestData( @@ -38,6 +38,7 @@ describe('CheckpointHeader', () => { blockHeadersHash: new Fr(456), blobsHash: new Fr(77), inHash: new Fr(88), + inboxRollingHash: new Fr(89), epochOutHash: new Fr(99), slotNumber: SlotNumber(1234), timestamp: BigInt(5678), @@ -49,7 +50,7 @@ describe('CheckpointHeader', () => { }); const hash = header.hash().toString(); - expect(hash).toMatchInlineSnapshot('"0x00d0dc440023ae006b0880b29ebfd5fda599d1aa7707f925229a362c5f24f3fc"'); + expect(hash).toMatchInlineSnapshot(`"0x00519b87177a8a5e4edd03f4d820aec6d402497ef1ab70e2ecd4d4c39b339611"`); // Run with AZTEC_GENERATE_TEST_DATA=1 to update noir test data updateInlineTestData( @@ -65,6 +66,7 @@ describe('CheckpointHeader', () => { blockHeadersHash: new Fr(MAX_FIELD_VALUE - 456n), blobsHash: new Fr(MAX_FIELD_VALUE - 77n), inHash: new Fr(MAX_FIELD_VALUE - 88n), + inboxRollingHash: new Fr(MAX_FIELD_VALUE - 89n), epochOutHash: new Fr(MAX_FIELD_VALUE - 99n), slotNumber: SlotNumber(1234), timestamp: 2n ** 64n - 1n - 5678n, @@ -79,7 +81,7 @@ describe('CheckpointHeader', () => { const hash = header.hash().toString(); - expect(hash).toMatchInlineSnapshot('"0x0077f763e5840cc3f24686ac79f58ef8a7f08c6418fd757e7e84566dc2eb032a"'); + expect(hash).toMatchInlineSnapshot(`"0x00d64307fa93c32ae46a4c3b6a1911d31994daa8d11d50201f0086a6cbaa9bac"`); // Run with AZTEC_GENERATE_TEST_DATA=1 to update noir test data updateInlineTestData( diff --git a/yarn-project/stdlib/src/rollup/checkpoint_header.ts b/yarn-project/stdlib/src/rollup/checkpoint_header.ts index 64b7d03e3062..32cbc58874e0 100644 --- a/yarn-project/stdlib/src/rollup/checkpoint_header.ts +++ b/yarn-project/stdlib/src/rollup/checkpoint_header.ts @@ -32,6 +32,12 @@ export class CheckpointHeader { public blobsHash: Fr, /** Root of the l1 to l2 messages subtree. */ public inHash: Fr, + /** + * Inbox rolling-hash chain value after consuming all L1-to-L2 messages bundled into this checkpoint. The dual of + * `inHash` (AZIP-22 Fast Inbox): the truncated-to-field sha256 chain the L1 Inbox accumulates. Currently a + * pass-through commitment; `inHash` remains the authoritative L1 check until the Fast Inbox flip. + */ + public inboxRollingHash: Fr, /** * The root of the epoch out hash balanced tree. The out hash of the first checkpoint in the epoch is inserted at * index 0, the second at index 1, and so on. @@ -63,6 +69,7 @@ export class CheckpointHeader { blockHeadersHash: schemas.Fr, blobsHash: schemas.Fr, inHash: schemas.Fr, + inboxRollingHash: schemas.Fr, epochOutHash: schemas.Fr, slotNumber: schemas.SlotNumber, timestamp: schemas.BigInt, @@ -81,6 +88,7 @@ export class CheckpointHeader { fields.blockHeadersHash, fields.blobsHash, fields.inHash, + fields.inboxRollingHash, fields.epochOutHash, fields.slotNumber, fields.timestamp, @@ -105,6 +113,7 @@ export class CheckpointHeader { reader.readObject(Fr), reader.readObject(Fr), reader.readObject(Fr), + reader.readObject(Fr), SlotNumber(Fr.fromBuffer(reader).toNumber()), reader.readUInt64(), reader.readObject(EthAddress), @@ -121,6 +130,7 @@ export class CheckpointHeader { this.blockHeadersHash.equals(other.blockHeadersHash) && this.blobsHash.equals(other.blobsHash) && this.inHash.equals(other.inHash) && + this.inboxRollingHash.equals(other.inboxRollingHash) && this.epochOutHash.equals(other.epochOutHash) && this.slotNumber === other.slotNumber && this.timestamp === other.timestamp && @@ -150,6 +160,7 @@ export class CheckpointHeader { this.blockHeadersHash, this.blobsHash, this.inHash, + this.inboxRollingHash, this.epochOutHash, new Fr(this.slotNumber), bigintToUInt64BE(this.timestamp), @@ -171,6 +182,7 @@ export class CheckpointHeader { blockHeadersHash: Fr.ZERO, blobsHash: Fr.ZERO, inHash: Fr.ZERO, + inboxRollingHash: Fr.ZERO, epochOutHash: Fr.ZERO, slotNumber: SlotNumber.ZERO, timestamp: 0n, @@ -189,6 +201,7 @@ export class CheckpointHeader { blockHeadersHash: Fr.random(), blobsHash: Fr.random(), inHash: Fr.random(), + inboxRollingHash: Fr.random(), epochOutHash: Fr.random(), slotNumber: SlotNumber(Math.floor(Math.random() * 1000) + 1), timestamp: BigInt(Math.floor(Date.now() / 1000)), @@ -207,6 +220,7 @@ export class CheckpointHeader { this.blockHeadersHash.isZero() && this.blobsHash.isZero() && this.inHash.isZero() && + this.inboxRollingHash.isZero() && this.epochOutHash.isZero() && this.slotNumber === 0 && this.timestamp === 0n && @@ -236,6 +250,7 @@ export class CheckpointHeader { Fr.fromString(header.blockHeadersHash), Fr.fromString(header.blobsHash), Fr.fromString(header.inHash), + Fr.fromString(header.inboxRollingHash), Fr.fromString(header.outHash), SlotNumber.fromBigInt(header.slotNumber), header.timestamp, @@ -261,6 +276,7 @@ export class CheckpointHeader { blockHeadersHash: this.blockHeadersHash.toString(), blobsHash: this.blobsHash.toString(), inHash: this.inHash.toString(), + inboxRollingHash: this.inboxRollingHash.toString(), outHash: this.epochOutHash.toString(), slotNumber: BigInt(this.slotNumber), timestamp: this.timestamp, @@ -281,6 +297,7 @@ export class CheckpointHeader { blockHeadersHash: this.blockHeadersHash.toString(), blobsHash: this.blobsHash.toString(), inHash: this.inHash.toString(), + inboxRollingHash: this.inboxRollingHash.toString(), epochOutHash: this.epochOutHash.toString(), slotNumber: this.slotNumber, timestamp: this.timestamp, @@ -298,6 +315,7 @@ export class CheckpointHeader { blockHeadersHash: ${this.blockHeadersHash.toString()}, blobsHash: ${inspect(this.blobsHash)}, inHash: ${inspect(this.inHash)}, + inboxRollingHash: ${inspect(this.inboxRollingHash)}, epochOutHash: ${inspect(this.epochOutHash)}, slotNumber: ${this.slotNumber}, timestamp: ${this.timestamp}, diff --git a/yarn-project/stdlib/src/rollup/checkpoint_rollup_public_inputs.ts b/yarn-project/stdlib/src/rollup/checkpoint_rollup_public_inputs.ts index dc3049babbe8..3ec8bfdbc31c 100644 --- a/yarn-project/stdlib/src/rollup/checkpoint_rollup_public_inputs.ts +++ b/yarn-project/stdlib/src/rollup/checkpoint_rollup_public_inputs.ts @@ -35,6 +35,15 @@ export class CheckpointRollupPublicInputs { * The out hash tree snapshot after applying this checkpoint range. */ public newOutHash: AppendOnlyTreeSnapshot, + /** + * Inbox rolling hash before consuming this checkpoint range's messages. + */ + public startInboxRollingHash: Fr, + /** + * Inbox rolling hash after consuming this checkpoint range's messages (the end value lands in the checkpoint + * header). Checkpoint merges assert `right.start == left.end` for chain continuity. + */ + public endInboxRollingHash: Fr, /** * The hashes of the headers of the constituent checkpoints. */ @@ -65,6 +74,8 @@ export class CheckpointRollupPublicInputs { reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot), reader.readObject(AppendOnlyTreeSnapshot), + Fr.fromBuffer(reader), + Fr.fromBuffer(reader), reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, Fr), reader.readArray(MAX_CHECKPOINTS_PER_EPOCH, FeeRecipient), reader.readObject(BlobAccumulator), @@ -80,6 +91,8 @@ export class CheckpointRollupPublicInputs { this.newArchive, this.previousOutHash, this.newOutHash, + this.startInboxRollingHash, + this.endInboxRollingHash, this.checkpointHeaderHashes, this.fees, this.startBlobAccumulator, @@ -108,6 +121,8 @@ export class CheckpointRollupPublicInputs { newArchiveRoot: this.newArchive.root.toString(), previousOutHashRoot: this.previousOutHash.root.toString(), newOutHashRoot: this.newOutHash.root.toString(), + startInboxRollingHash: this.startInboxRollingHash.toString(), + endInboxRollingHash: this.endInboxRollingHash.toString(), }; } diff --git a/yarn-project/stdlib/src/rollup/checkpoint_root_rollup_private_inputs.ts b/yarn-project/stdlib/src/rollup/checkpoint_root_rollup_private_inputs.ts index bb15e9110fb0..7838c30ee375 100644 --- a/yarn-project/stdlib/src/rollup/checkpoint_root_rollup_private_inputs.ts +++ b/yarn-project/stdlib/src/rollup/checkpoint_root_rollup_private_inputs.ts @@ -7,7 +7,8 @@ import { BufferReader, type Tuple, serializeToBuffer } from '@aztec/foundation/s import { bufferToHex, hexToBuffer } from '@aztec/foundation/string'; import type { FieldsOf } from '@aztec/foundation/types'; -import { ProofData, type RollupHonkProofData } from '../proofs/proof_data.js'; +import { ParityPublicInputs } from '../parity/parity_public_inputs.js'; +import { ProofData, type RollupHonkProofData, type UltraHonkProofData } from '../proofs/proof_data.js'; import { AppendOnlyTreeSnapshot } from '../trees/append_only_tree_snapshot.js'; import { BlockHeader } from '../tx/block_header.js'; import { BlockRollupPublicInputs } from './block_rollup_public_inputs.js'; @@ -117,6 +118,11 @@ export class CheckpointRootRollupPrivateInputs { RollupHonkProofData, RollupHonkProofData, ], + /** + * Inbox parity proof over the checkpoint's L1-to-L2 messages (AZIP-22 Fast Inbox): it commits to the same message + * list behind the L1-checked `inHash`, and its message sponge is checked against the blocks' accumulated one. + */ + public inboxParity: UltraHonkProofData, public hints: CheckpointRootRollupHints, ) {} @@ -125,7 +131,7 @@ export class CheckpointRootRollupPrivateInputs { } static getFields(fields: FieldsOf) { - return [fields.previousRollups, fields.hints] as const; + return [fields.previousRollups, fields.inboxParity, fields.hints] as const; } toBuffer() { @@ -136,6 +142,7 @@ export class CheckpointRootRollupPrivateInputs { const reader = BufferReader.asReader(buffer); return new CheckpointRootRollupPrivateInputs( [ProofData.fromBuffer(reader, BlockRollupPublicInputs), ProofData.fromBuffer(reader, BlockRollupPublicInputs)], + ProofData.fromBuffer(reader, ParityPublicInputs), CheckpointRootRollupHints.fromBuffer(reader), ); } @@ -160,6 +167,11 @@ export class CheckpointRootRollupPrivateInputs { export class CheckpointRootSingleBlockRollupPrivateInputs { constructor( public previousRollup: RollupHonkProofData, + /** + * Inbox parity proof over the checkpoint's L1-to-L2 messages (AZIP-22 Fast Inbox): it commits to the same message + * list behind the L1-checked `inHash`, and its message sponge is checked against the block's accumulated one. + */ + public inboxParity: UltraHonkProofData, public hints: CheckpointRootRollupHints, ) {} @@ -170,7 +182,7 @@ export class CheckpointRootSingleBlockRollupPrivateInputs { } static getFields(fields: FieldsOf) { - return [fields.previousRollup, fields.hints] as const; + return [fields.previousRollup, fields.inboxParity, fields.hints] as const; } toBuffer() { @@ -181,6 +193,7 @@ export class CheckpointRootSingleBlockRollupPrivateInputs { const reader = BufferReader.asReader(buffer); return new CheckpointRootSingleBlockRollupPrivateInputs( ProofData.fromBuffer(reader, BlockRollupPublicInputs), + ProofData.fromBuffer(reader, ParityPublicInputs), CheckpointRootRollupHints.fromBuffer(reader), ); } diff --git a/yarn-project/stdlib/src/rollup/root_rollup_public_inputs.ts b/yarn-project/stdlib/src/rollup/root_rollup_public_inputs.ts index 9c362ccd9e59..9851203e45d9 100644 --- a/yarn-project/stdlib/src/rollup/root_rollup_public_inputs.ts +++ b/yarn-project/stdlib/src/rollup/root_rollup_public_inputs.ts @@ -26,6 +26,10 @@ export class RootRollupPublicInputs { * The out hash of the first checkpoint in the epoch is inserted at index 0, the second at index 1, and so on. */ public outHash: Fr, + /** Inbox rolling hash before the epoch's first checkpoint's messages. */ + public previousInboxRollingHash: Fr, + /** Inbox rolling hash after the epoch's last checkpoint's messages. */ + public endInboxRollingHash: Fr, /** Hashes of checkpoint headers for this rollup. */ public checkpointHeaderHashes: Tuple, public fees: Tuple, @@ -38,6 +42,8 @@ export class RootRollupPublicInputs { fields.previousArchiveRoot, fields.endArchiveRoot, fields.outHash, + fields.previousInboxRollingHash, + fields.endInboxRollingHash, fields.checkpointHeaderHashes, fields.fees, fields.constants, @@ -65,6 +71,8 @@ export class RootRollupPublicInputs { public static fromBuffer(buffer: Buffer | BufferReader): RootRollupPublicInputs { const reader = BufferReader.asReader(buffer); return new RootRollupPublicInputs( + Fr.fromBuffer(reader), + Fr.fromBuffer(reader), Fr.fromBuffer(reader), Fr.fromBuffer(reader), Fr.fromBuffer(reader), @@ -96,6 +104,8 @@ export class RootRollupPublicInputs { /** Creates a random instance. Used for testing only - will not prove/verify. */ static random() { return new RootRollupPublicInputs( + Fr.random(), + Fr.random(), Fr.random(), Fr.random(), Fr.random(), diff --git a/yarn-project/stdlib/src/stats/stats.ts b/yarn-project/stdlib/src/stats/stats.ts index cc79352f8bd7..a1816ec6e966 100644 --- a/yarn-project/stdlib/src/stats/stats.ts +++ b/yarn-project/stdlib/src/stats/stats.ts @@ -101,8 +101,9 @@ export type ClientCircuitName = | 'app-circuit'; export type ServerCircuitName = - | 'parity-base' - | 'parity-root' + | 'inbox-parity-64' + | 'inbox-parity-256' + | 'inbox-parity-1024' | 'chonk-verifier-public' | 'rollup-tx-base-private' | 'rollup-tx-base-public' @@ -112,6 +113,7 @@ export type ServerCircuitName = | 'rollup-block-root-first-empty-tx' | 'rollup-block-root' | 'rollup-block-root-single-tx' + | 'rollup-block-root-msgs-only' | 'rollup-block-merge' | 'rollup-checkpoint-root' | 'rollup-checkpoint-root-single-block' diff --git a/yarn-project/stdlib/src/tests/factories.ts b/yarn-project/stdlib/src/tests/factories.ts index 5cff56878429..58374d0ae2d5 100644 --- a/yarn-project/stdlib/src/tests/factories.ts +++ b/yarn-project/stdlib/src/tests/factories.ts @@ -9,12 +9,14 @@ import { AVM_V2_PROOF_LENGTH_IN_FIELDS, CHONK_PROOF_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, - L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH, + INBOX_PARITY_SIZE_SMALL, + L1_TO_L2_MSG_TREE_HEIGHT, MAX_CHECKPOINTS_PER_EPOCH, MAX_CONTRACT_CLASS_LOGS_PER_TX, MAX_ENQUEUED_CALLS_PER_CALL, MAX_ENQUEUED_CALLS_PER_TX, MAX_KEY_VALIDATION_REQUESTS_PER_CALL, + MAX_L1_TO_L2_MSGS_PER_BLOCK, MAX_L2_TO_L1_MSGS_PER_CALL, MAX_L2_TO_L1_MSGS_PER_TX, MAX_NOTE_HASHES_PER_CALL, @@ -35,8 +37,6 @@ import { NULLIFIER_SUBTREE_ROOT_SIBLING_PATH_LENGTH, NULLIFIER_TREE_HEIGHT, NUMBER_OF_L1_L2_MESSAGES_PER_ROLLUP, - NUM_BASE_PARITY_PER_ROOT_PARITY, - NUM_MSGS_PER_BASE_PARITY, PRIVATE_LOG_SIZE_IN_FIELDS, PUBLIC_DATA_TREE_HEIGHT, RECURSIVE_ROLLUP_HONK_PROOF_LENGTH, @@ -129,10 +129,11 @@ import { ContractClassLog, ContractClassLogFields } from '../logs/index.js'; import type { LogResult } from '../logs/log_result.js'; import { PrivateLog } from '../logs/private_log.js'; import { FlatPublicLogs, PublicLog } from '../logs/public_log.js'; +import { L1ToL2MessageBundle } from '../messaging/l1_to_l2_message_bundle.js'; +import { L1ToL2MessageSponge } from '../messaging/l1_to_l2_message_sponge.js'; import { CountedL2ToL1Message, L2ToL1Message, ScopedL2ToL1Message } from '../messaging/l2_to_l1_message.js'; -import { ParityBasePrivateInputs } from '../parity/parity_base_private_inputs.js'; +import { InboxParityPrivateInputs } from '../parity/inbox_parity_private_inputs.js'; import { ParityPublicInputs } from '../parity/parity_public_inputs.js'; -import { ParityRootPrivateInputs } from '../parity/parity_root_private_inputs.js'; import { ProofData, ProofDataForFixedVk } from '../proofs/index.js'; import { Proof } from '../proofs/proof.js'; import { makeRecursiveProof } from '../proofs/recursive_proof.js'; @@ -788,13 +789,19 @@ export function makeBlockRollupPublicInputs(seed = 0): BlockRollupPublicInputs { makeSpongeBlob(seed + 0x700), BigInt(seed + 0x800), fr(seed + 0x820), - fr(seed + 0x830), + (seed & 1) === 0, + makeL1ToL2MessageSponge(seed + 0x835), + makeL1ToL2MessageSponge(seed + 0x838), fr(seed + 0x840), fr(seed + 0x850), fr(seed + 0x860), ); } +export function makeL1ToL2MessageSponge(seed = 0): L1ToL2MessageSponge { + return new L1ToL2MessageSponge(makeSpongeBlob(seed).sponge, seed % (INBOX_PARITY_SIZE_SMALL + 1)); +} + export function makeCheckpointRollupPublicInputs(seed = 0) { return new CheckpointRollupPublicInputs( makeEpochConstantData(seed), @@ -802,6 +809,8 @@ export function makeCheckpointRollupPublicInputs(seed = 0) { makeAppendOnlyTreeSnapshot(seed + 0x200), makeAppendOnlyTreeSnapshot(seed + 0x300), makeAppendOnlyTreeSnapshot(seed + 0x350), + fr(seed + 0x360), + fr(seed + 0x370), makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => fr(seed), 0x400), makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => makeFeeRecipient(seed), 0x500), makeBlobAccumulator(seed + 0x600), @@ -813,26 +822,32 @@ export function makeCheckpointRollupPublicInputs(seed = 0) { export function makeParityPublicInputs(seed = 0): ParityPublicInputs { return new ParityPublicInputs( new Fr(BigInt(seed + 0x200)), - new Fr(BigInt(seed + 0x300)), new Fr(BigInt(seed + 0x400)), new Fr(BigInt(seed + 0x500)), + makeL1ToL2MessageSponge(seed + 0x550), + makeL1ToL2MessageSponge(seed + 0x580), + seed + 0x600, + new Fr(BigInt(seed + 0x700)), + new Fr(BigInt(seed + 0x800)), ); } -export function makeParityBasePrivateInputs(seed = 0): ParityBasePrivateInputs { - return new ParityBasePrivateInputs( - makeTuple(NUM_MSGS_PER_BASE_PARITY, fr, seed + 0x3000), +export function makeInboxParityPrivateInputs(seed = 0): InboxParityPrivateInputs { + const size = INBOX_PARITY_SIZE_SMALL; + const numMsgs = seed % (size + 1); + const messages = Array.from({ length: size }, (_, i) => (i < numMsgs ? fr(i + seed + 0x3000) : Fr.ZERO)); + return new InboxParityPrivateInputs( + size, + messages, + numMsgs, + new Fr(seed + 0x3500), + makeL1ToL2MessageSponge(seed + 0x3800), + new Fr(seed + 0x3900), new Fr(seed + 0x4000), new Fr(seed + 0x5000), ); } -export function makeParityRootPrivateInputs(seed = 0) { - return new ParityRootPrivateInputs( - makeTuple(NUM_BASE_PARITY_PER_ROOT_PARITY, () => makeProofData(seed, makeParityPublicInputs)), - ); -} - /** * Makes root rollup public inputs. * @param seed - The seed to use for generating the root rollup public inputs. @@ -844,6 +859,8 @@ export function makeRootRollupPublicInputs(seed = 0): RootRollupPublicInputs { fr(seed + 0x100), fr(seed + 0x200), fr(seed + 0x300), + fr(seed + 0x320), + fr(seed + 0x340), makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => fr(seed), 0x400), makeTuple(MAX_CHECKPOINTS_PER_EPOCH, () => makeFeeRecipient(seed), 0x500), makeEpochConstantData(seed + 0x600), @@ -872,6 +889,7 @@ export function makeCheckpointHeader(seed = 0, overrides: Partial { @@ -339,6 +340,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder { constants, l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, fork, bindings, feeAssetPriceModifier, @@ -366,6 +368,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder { feeAssetPriceModifier: bigint, l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], + previousInboxRollingHash: Fr, fork: MerkleTreeWriteOperations, existingBlocks: L2Block[] = [], bindings?: LoggerBindings, @@ -380,6 +383,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder { feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, fork, bindings, ); @@ -401,6 +405,7 @@ export class FullNodeCheckpointsBuilder implements ICheckpointsBuilder { feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, fork, existingBlocks, bindings, diff --git a/yarn-project/validator-client/src/proposal_handler.ts b/yarn-project/validator-client/src/proposal_handler.ts index e1bec3a450f5..96f20aada864 100644 --- a/yarn-project/validator-client/src/proposal_handler.ts +++ b/yarn-project/validator-client/src/proposal_handler.ts @@ -22,7 +22,11 @@ import type { P2P, PeerId } from '@aztec/p2p'; import { BlockProposalValidator } from '@aztec/p2p/msg_validators'; import type { BlockData, L2Block, L2BlockSink, L2BlockSource } from '@aztec/stdlib/block'; import type { CheckpointReexecutionTracker, ReexecutionOutcome } from '@aztec/stdlib/checkpoint'; -import { getPreviousCheckpointOutHashes, validateCheckpoint } from '@aztec/stdlib/checkpoint'; +import { + getPreviousCheckpointInboxRollingHash, + getPreviousCheckpointOutHashes, + validateCheckpoint, +} from '@aztec/stdlib/checkpoint'; import { getEpochAtSlot } from '@aztec/stdlib/epoch-helpers'; import { Gas } from '@aztec/stdlib/gas'; import type { @@ -584,6 +588,12 @@ export class ProposalHandler { log: this.log, }); + const previousInboxRollingHash = await getPreviousCheckpointInboxRollingHash({ + blockSource: this.blockSource, + checkpointNumber, + log: this.log, + }); + // Try re-executing the transactions in the proposal if needed let reexecutionResult; try { @@ -595,6 +605,7 @@ export class ProposalHandler { txs, l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, ); } catch (error) { this.log.error(`Error reexecuting txs while processing block proposal`, error, proposalInfo); @@ -882,6 +893,7 @@ export class ProposalHandler { txs: Tx[], l1ToL2Messages: Fr[], previousCheckpointOutHashes: Fr[], + previousInboxRollingHash: Fr, ): Promise { const { blockHeader, txHashes } = proposal; @@ -930,6 +942,7 @@ export class ProposalHandler { 0n, // only takes effect in the following checkpoint. l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, fork, priorBlocks, this.log.getBindings(), @@ -1173,6 +1186,12 @@ export class ProposalHandler { log: this.log, }); + const previousInboxRollingHash = await getPreviousCheckpointInboxRollingHash({ + blockSource: this.blockSource, + checkpointNumber, + log: this.log, + }); + // Fork world state at the block before the first block. getFork syncs world state to the parent block // first (see its doc): the block source (archiver) can already hold the block while world state still // trails it by one, and forking a not-yet-applied block throws a raw tree error that would otherwise @@ -1216,6 +1235,7 @@ export class ProposalHandler { proposal.feeAssetPriceModifier, l1ToL2Messages, previousCheckpointOutHashes, + previousInboxRollingHash, fork, blocks, this.log.getBindings(), diff --git a/yarn-project/validator-client/src/validator.integration.test.ts b/yarn-project/validator-client/src/validator.integration.test.ts index aa89cae85e20..4dbb9302ce25 100644 --- a/yarn-project/validator-client/src/validator.integration.test.ts +++ b/yarn-project/validator-client/src/validator.integration.test.ts @@ -334,6 +334,7 @@ describe('ValidatorClient Integration', () => { 0n, l1ToL2Messages, previousCheckpointOutHashes, + Fr.ZERO, fork, ); diff --git a/yarn-project/validator-client/src/validator.test.ts b/yarn-project/validator-client/src/validator.test.ts index 1ec793384eaa..0dbc04e997a4 100644 --- a/yarn-project/validator-client/src/validator.test.ts +++ b/yarn-project/validator-client/src/validator.test.ts @@ -30,10 +30,11 @@ import { import { OffenseType, WANT_TO_CLEAR_SLASH_EVENT, WANT_TO_SLASH_EVENT } from '@aztec/slasher'; import { AztecAddress } from '@aztec/stdlib/aztec-address'; import { type BlockData, BlockHash, L2Block, type L2BlockSink, type L2BlockSource } from '@aztec/stdlib/block'; -import { type Checkpoint, CheckpointReexecutionTracker } from '@aztec/stdlib/checkpoint'; +import { type Checkpoint, CheckpointReexecutionTracker, type ProposedCheckpointData } from '@aztec/stdlib/checkpoint'; import type { SlasherConfig, WorldStateSynchronizer } from '@aztec/stdlib/interfaces/server'; import { type L1ToL2MessageSource, computeInHashFromL1ToL2Messages } from '@aztec/stdlib/messaging'; import type { BlockProposal } from '@aztec/stdlib/p2p'; +import { CheckpointHeader } from '@aztec/stdlib/rollup'; import { TEST_COORDINATION_SIGNATURE_CONTEXT, makeBlockHeader, @@ -166,6 +167,15 @@ describe('ValidatorClient', () => { blockSource.getBlocksForSlot.mockResolvedValue([]); blockSource.getSyncedL2SlotNumber.mockResolvedValue(SlotNumber(Number.MAX_SAFE_INTEGER)); blockSource.syncImmediate.mockResolvedValue(undefined); + // The proposal handler sources the parent checkpoint's inboxRollingHash from the block source; serve an + // empty (all-zero) parent header from the proposed-checkpoint fallback so proposals beyond the genesis + // checkpoint resolve their chain start. getCheckpointData stays undefined: the checkpoint-proposal path + // uses it as an already-published-on-L1 existence check. + blockSource.getProposedCheckpointData.mockImplementation(query => + Promise.resolve( + query && 'number' in query ? ({ header: CheckpointHeader.empty() } as ProposedCheckpointData) : undefined, + ), + ); epochCache.isEscapeHatchOpenAtSlot.mockResolvedValue(false); l1ToL2MessageSource = mock(); txProvider = mock();