Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.22;

import { MerkleProof } from "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import { ReentrancyGuard } from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import { MultiSig } from "./MultiSig.sol";
import { ExecutorStore } from "./ExecutorStore.sol";

/**
 * @title OneSig
 * @author @TRileySchwarz, @Clearwood, @HansonYip, @mok-lz
 * @notice A multi-chain enabled contract that uses a Merkle tree of transaction leaves.
 *         It allows transactions to be signed once (off-chain) and then executed on multiple chains,
 *         provided the Merkle proof is valid and the threshold of signers is met.
 * @dev Inherits from MultiSig for signature threshold logic.
 */
contract OneSig is MultiSig, ReentrancyGuard, ExecutorStore {
    /// @notice The version string of the OneSig contract.
    string public constant VERSION = "0.0.1";

    uint8 public constant LEAF_ENCODING_VERSION = 1;

    /**
     * @dev EIP-191 defines the format of the signature prefix.
     *      See https://eips.ethereum.org/EIPS/eip-191
     */
    string private constant EIP191_PREFIX_FOR_EIP712 = "\x19\x01";

    /**
     * @dev EIP-712 domain separator type-hash.
     *      See https://eips.ethereum.org/EIPS/eip-712
     */
    bytes32 private constant EIP712DOMAIN_TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    /**
     * @dev This domain separator is used to generate a signature hash for the merkle root,
     *      specifically using chainId = 1 (Ethereum Mainnet) and verifyingContract = 0xdEaD.
     *      This ensures that the same merkle root signatures can be used across different chains
     *      because they are all signed with this consistent "fake" domain.
     *
     *      In other words, to verify the merkle root with the same signatures on different chains,
     *      we use the same chainId (1) and verifyingContract (0xdEaD) in the EIP-712 domain.
     */
    bytes32 private constant DOMAIN_SEPARATOR =
        keccak256(
            abi.encode(
                EIP712DOMAIN_TYPE_HASH,
                keccak256(bytes("OneSig")), // this contract name
                keccak256(bytes(VERSION)), // version
                1, // Ethereum mainnet chainId
                address(0xdEaD) // verifyingContract
            )
        );

    /**
     * @dev The type-hash of the data being signed to authorize a merkle root.
     */
    bytes32 private constant SIGN_MERKLE_ROOT_TYPE_HASH =
        keccak256("SignMerkleRoot(bytes32 seed,bytes32 merkleRoot,uint256 expiry)");

    /**
     * @notice The OneSig ID of the contract.
     * @dev Because the oneSigId is part of the leaf, the same signatures can be used on different chains,
     *      while leaving each transaction to be targetted towards one
     */
    uint64 public immutable ONE_SIG_ID;

    /**
     * @notice A random seed encoded into the signatures/root.
     * @dev Allows for a previously signed, but unexecuted, transaction(s) to be 'revoked' by changing the seed.
     */
    bytes32 public seed;

    /**
     * @notice A sequential nonce to prevent replay attacks and enforce transaction ordering.
     */
    uint64 public nonce;

    /// @notice Emitted when the seed is updated.
    event SeedSet(bytes32 seed);

    /// @notice Emitted when a transaction is executed.
    /// @param merkleRoot The merkle root used to authorize the transaction.
    /// @param nonce The nonce of the transaction.
    event TransactionExecuted(bytes32 merkleRoot, uint256 nonce);

    /// @notice Error thrown when a merkle proof is invalid or the nonce does not match the expected value.
    error InvalidProofOrNonce();

    /// @notice Error thrown when a merkle root has expired (past the _expiry timestamp).
    error MerkleRootExpired();

    /// @notice Error thrown when a call in the transaction array fails.
    /// @param index The index of the failing call within the transaction.
    error ExecutionFailed(uint256 index);

    /// @notice Error thrown when a function is not called from an executor or signer.
    error OnlyExecutorOrSigner();

    /**
     * @notice Call to be executed as part of a Transaction.calls.
     *  - OneSig -> [Arbitrary contract].
     *  - e.g., setPeer(dstEid, remoteAddress).
     * @param to Address of the contract for this data to be 'called' on.
     * @param value Amount of ether to send with this call.
     * @param data Encoded data to be sent to the contract (calldata).
     */
    struct Call {
        address to;
        uint256 value;
        bytes data;
    }

    /**
     * @notice Single call to the OneSig contract (address(this)).
     *  - EOA -> OneSig
     *  - This struct is 1:1 with a 'leaf' in the merkle tree.
     *  - Execution of the underlying calls are atomic.
     *  - Cannot be processed until the previous leaf (nonce-ordered) has been executed successfully.
     * @param calls List of calls to be made.
     * @param proof Merkle proof to verify the transaction.
     */
    struct Transaction {
        Call[] calls;
        bytes32[] proof;
    }

    /**
     * @dev Restricts access to functions so they can only be called via an executor, OR a multisig signer.
     */
    modifier onlyExecutorOrSigner() {
        if (!canExecuteTransaction(msg.sender)) revert OnlyExecutorOrSigner();
        _;
    }

    /**
     * @notice Constructor to initialize the OneSig contract.
     * @dev Inherits MultiSig(_signers, _threshold).
     * @param _oneSigId A unique identifier per deployment, (typically block.chainid).
     * @param _signers The list of signers authorized to sign transactions.
     * @param _threshold The initial threshold of signers required to execute a transaction.
     * @param _executors The list of executors authorized to execute transactions.
     * @param _executorRequired If executors are required to execute transactions.
     * @param _seed The random seed to encode into the signatures/root.
     */
    constructor(
        uint64 _oneSigId,
        address[] memory _signers,
        uint256 _threshold,
        address[] memory _executors,
        bool _executorRequired,
        bytes32 _seed
    ) MultiSig(_signers, _threshold) ExecutorStore(_executors, _executorRequired) {
        ONE_SIG_ID = _oneSigId;
        _setSeed(_seed);
    }

    /**
     * @notice Internal method to set the contract's seed.
     * @param _seed The new seed value.
     */
    function _setSeed(bytes32 _seed) internal virtual {
        seed = _seed;
        emit SeedSet(_seed);
    }

    /**
     * @notice Sets the contract's seed.
     * @dev Only callable via MultiSig functionality (i.e., requires threshold signatures from signers).
     * @param _seed The new seed value.
     */
    function setSeed(bytes32 _seed) public virtual onlySelfCall {
        _setSeed(_seed);
    }

    /**
     * @notice Executes a single transaction (which corresponds to a leaf in the merkle tree) if valid signatures are provided.
     * @dev '_transaction' corresponds 1:1 with a leaf. This function can be called by anyone (permissionless),
     *      provided the merkle root is verified with sufficient signatures.
     * @param _transaction The transaction data struct, including calls and proof.
     * @param _merkleRoot The merkle root that authorizes this transaction.
     * @param _expiry The timestamp after which the merkle root expires.
     * @param _signatures Signatures from signers that meet the threshold.
     */
    function executeTransaction(
        Transaction calldata _transaction,
        bytes32 _merkleRoot,
        uint256 _expiry,
        bytes calldata _signatures
    ) public payable virtual nonReentrant onlyExecutorOrSigner {
        // Verify the merkle root and signatures
        verifyMerkleRoot(_merkleRoot, _expiry, _signatures);

        // Verify that this transaction matches the merkle root (using its proof)
        verifyTransactionProof(_merkleRoot, _transaction);

        // Increment nonce before execution to prevent replay
        uint256 n = nonce++;

        // Execute all calls atomically
        for (uint256 i = 0; i < _transaction.calls.length; i++) {
            (bool success, ) = _transaction.calls[i].to.call{ value: _transaction.calls[i].value }(
                _transaction.calls[i].data
            );

            // Revert if the call fails
            if (!success) revert ExecutionFailed(i);
        }

        emit TransactionExecuted(_merkleRoot, n);
    }

    /**
     * @notice Validates the signatures on a given merkle root.
     * @dev Reverts if the merkle root is expired or signatures do not meet the threshold.
     * @param _merkleRoot The merkle root to verify.
     * @param _expiry The timestamp after which the merkle root becomes invalid.
     * @param _signatures The provided signatures.
     */
    function verifyMerkleRoot(bytes32 _merkleRoot, uint256 _expiry, bytes calldata _signatures) public view {
        // Check expiry
        if (block.timestamp > _expiry) revert MerkleRootExpired();

        // Compute the EIP-712 hash
        bytes32 digest = keccak256(
            abi.encodePacked(
                EIP191_PREFIX_FOR_EIP712,
                DOMAIN_SEPARATOR,
                keccak256(abi.encode(SIGN_MERKLE_ROOT_TYPE_HASH, seed, _merkleRoot, _expiry))
            )
        );

        // Verify the threshold signatures
        verifySignatures(digest, _signatures);
    }

    /**
     * @notice Verifies that the provided merkle proof matches the current transaction leaf under the merkle root.
     * @dev Reverts if the proof is invalid or the nonce doesn't match the expected value.
     * @param _merkleRoot The merkle root being used.
     * @param _transaction The transaction data containing proof and calls.
     */
    function verifyTransactionProof(bytes32 _merkleRoot, Transaction calldata _transaction) public view {
        bytes32 leaf = encodeLeaf(nonce, _transaction.calls);
        bool valid = MerkleProof.verifyCalldata(_transaction.proof, _merkleRoot, leaf);
        if (!valid) revert InvalidProofOrNonce();
    }

    /**
     * @notice Double encodes the transaction leaf for inclusion in the merkle tree.
     * @param _nonce The nonce of the transaction.
     * @param _calls The calls to be made in this transaction.
     * @return The keccak256 hash of the encoded leaf.
     */
    function encodeLeaf(uint64 _nonce, Call[] calldata _calls) public view returns (bytes32) {
        return
            keccak256(
                abi.encodePacked(
                    keccak256(
                        abi.encodePacked(
                            LEAF_ENCODING_VERSION,
                            ONE_SIG_ID,
                            bytes32(uint256(uint160(address(this)))), // convert address(this) into bytes32
                            _nonce,
                            abi.encode(_calls)
                        )
                    )
                )
            );
    }

    /**
     * @notice Checks if the a given address can execute a transaction.
     * @param _sender The address of the message sender.
     * @return True if executeTransaction can be called by the executor, otherwise false.
     */
    function canExecuteTransaction(address _sender) public view returns (bool) {
        // If the flag is set to false, then ANYONE can execute permissionlessly, otherwise the msg.sender must be a executor, or a signer
        return (!executorRequired || isExecutor(_sender) || isSigner(_sender));
    }

    /**
     * @notice Fallback function to receive ether.
     * @dev Allows the contract to accept ETH.
     */
    receive() external payable {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.20;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            uint8 v = uint8((uint256(vs) >> 255) + 27);
            return tryRecover(hash, v, r, s);
        }
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS, s);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.20;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The tree and the proofs can be generated using our
 * https://github.com/OpenZeppelin/merkle-tree[JavaScript library].
 * You will find a quickstart guide in the readme.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the Merkle tree could be reinterpreted as a leaf value.
 * OpenZeppelin's JavaScript library generates Merkle trees that are safe
 * against this attack out of the box.
 */
library MerkleProof {
    /**
     *@dev The multiproof provided is not valid.
     */
    error MerkleProofInvalidMultiproof();

    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(bytes32[] memory proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     */
    function verifyCalldata(bytes32[] calldata proof, bytes32 root, bytes32 leaf) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be simultaneously proven to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and sibling nodes in `proof`. The reconstruction
     * proceeds by incrementally reconstructing all inner nodes by combining a leaf/inner node with either another
     * leaf/inner node or a proof sibling node, depending on whether each `proofFlags` item is true or false
     * respectively.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. To use multiproofs, it is sufficient to ensure that: 1) the tree
     * is complete (but not necessarily perfect), 2) the leaves to be proven are in the opposite order they are in the
     * tree (i.e., as seen from right to left starting at the deepest layer and continuing at the next layer).
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}.
     *
     * CAUTION: Not all Merkle trees admit multiproofs. See {processMultiProof} for details.
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuilds the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the Merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 proofLen = proof.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        if (leavesLen + proofLen != totalHashes + 1) {
            revert MerkleProofInvalidMultiproof();
        }

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value from the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i]
                ? (leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++])
                : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            if (proofPos != proofLen) {
                revert MerkleProofInvalidMultiproof();
            }
            unchecked {
                return hashes[totalHashes - 1];
            }
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Sorts the pair (a, b) and hashes the result.
     */
    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    /**
     * @dev Implementation of keccak256(abi.encode(a, b)) that doesn't allocate or expand memory.
     */
    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.20;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position is the index of the value in the `values` array plus 1.
        // Position 0 is used to mean a value is not in the set.
        mapping(bytes32 value => uint256) _positions;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._positions[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We cache the value's position to prevent multiple reads from the same storage slot
        uint256 position = set._positions[value];

        if (position != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 valueIndex = position - 1;
            uint256 lastIndex = set._values.length - 1;

            if (valueIndex != lastIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the lastValue to the index where the value to delete is
                set._values[valueIndex] = lastValue;
                // Update the tracked position of the lastValue (that was just moved)
                set._positions[lastValue] = position;
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the tracked position for the deleted slot
            delete set._positions[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._positions[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.22;

import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { SelfCallable } from "./lib/SelfCallable.sol";

/**
 * @title ExecutorStore
 * @notice Abstract contract that manages a set of executors and a whether they are required.
 * @dev Uses EnumerableSet to store executor addresses
 */
abstract contract ExecutorStore is SelfCallable {
    using EnumerableSet for EnumerableSet.AddressSet;

    /**
     * @dev Set of available executors for the MultiSig.
     */
    EnumerableSet.AddressSet internal executorSet;

    /**
     * @notice Whether the executor permission is required to execute a transaction.
     */
    bool public executorRequired;

    /// @notice Error thrown when an executor address is invalid.
    /// @dev This error is thrown when the address is zero.
    error InvalidExecutor();

    /// @notice Error thrown when attempting to add an execute who is already active.
    /// @param executor The address of the executor.
    error ExecutorAlreadyActive(address executor);

    /// @notice Error thrown when attempting to remove an execute who is not found.
    /// @param executor The address of the executor.
    error ExecutorNotFound(address executor);

    /**
     * @notice Emitted when an executor's active status is updated.
     * @param executor The address of the executor.
     * @param active True if added, false if removed.
     */
    event ExecutorSet(address indexed executor, bool active);

    /**
     * @notice Emitted when the executor required state is updated.
     * @param required The new state
     */
    event ExecutorRequiredSet(bool required);

    /**
     * @dev Initializes the ExecutorStore with a list of executors and sets whether executors are required.
     * @param _executors Array of executor addresses, can be empty.
     * @dev If the array is empty, executorsRequired will be set to false.
     */
    constructor(address[] memory _executors, bool _executorRequired) {
        for (uint256 i = 0; i < _executors.length; i++) {
            _addExecutor(_executors[i]);
        }
        _setExecutorRequired(_executorRequired);
    }

    /**
     * @dev Sets whether executors are required.
     * @param _executorRequired The new threshold value.
     */
    function setExecutorRequired(bool _executorRequired) external onlySelfCall {
        _setExecutorRequired(_executorRequired);
    }

    /**
     * @dev Internal function to set whether executors are required for this MultiSig.
     * @param _executorRequired The new value.
     */
    function _setExecutorRequired(bool _executorRequired) internal {
        executorRequired = _executorRequired;
        emit ExecutorRequiredSet(_executorRequired);
    }

    /**
     * @notice Adds or removes an executor from this MultiSig.
     * @dev Only callable via the MultiSig contract itself.
     * @param _executor The address of the executor to add/remove.
     * @param _active True to add executor, false to remove executor.
     */
    function setExecutor(address _executor, bool _active) external onlySelfCall {
        if (_active) {
            _addExecutor(_executor);
        } else {
            _removeExecutor(_executor);
        }
    }

    /**
     * @dev Internal function to add an executor.
     * @param _executor The address of the executor to add.
     */
    function _addExecutor(address _executor) internal {
        if (_executor == address(0)) revert InvalidExecutor();
        if (!executorSet.add(_executor)) revert ExecutorAlreadyActive(_executor);
        emit ExecutorSet(_executor, true);
    }

    /**
     * @dev Internal function to remove an executor.
     * @param _executor The address of the executor to remove.
     */
    function _removeExecutor(address _executor) internal {
        if (!executorSet.remove(_executor)) revert ExecutorNotFound(_executor);
        emit ExecutorSet(_executor, false);
    }

    /**
     * @notice Returns the list of all active executors.
     * @return An array of addresses representing the current set of executors.
     */
    function getExecutors() public view returns (address[] memory) {
        return executorSet.values();
    }

    /**
     * @notice Checks if a given address is in the set of executors.
     * @param _executor The address to check.
     * @return True if the address is a executor, otherwise false.
     */
    function isExecutor(address _executor) public view returns (bool) {
        return executorSet.contains(_executor);
    }

    /**
     * @notice Returns the total number of active executors.
     * @return The number of executors currently active.
     */
    function totalExecutors() public view returns (uint256) {
        return executorSet.length();
    }
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.22;

abstract contract SelfCallable {
    /// @notice Error thrown when attempting to call a function from an invalid address.
    error OnlySelfCall();

    /**
     * @dev Restricts access to functions so they can only be called via this contract itself.
     */
    modifier onlySelfCall() {
        if (msg.sender != address(this)) revert OnlySelfCall();
        _;
    }
}

// SPDX-License-Identifier: GPL-3.0

pragma solidity ^0.8.22;

import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import { EnumerableSet } from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
import { SelfCallable } from "./lib/SelfCallable.sol";

/**
 * @title MultiSig
 * @notice Abstract contract that manages a set of signers and a signature threshold.
 *         Designed to be inherited by contracts requiring multi-signature verification.
 * @dev Uses EnumerableSet to store signer addresses and ECDSA for signature recovery.
 */
abstract contract MultiSig is SelfCallable {
    using EnumerableSet for EnumerableSet.AddressSet;

    /**
     * @dev Set of available signers for the MultiSig.
     */
    EnumerableSet.AddressSet internal signerSet;

    /**
     * @notice The number of signatures required to execute a transaction.
     */
    uint256 public threshold;

    /// @notice Error thrown when a signer address is invalid.
    error InvalidSigner();

    /// @notice Error thrown when the threshold is set to zero.
    error ZeroThreshold();

    /// @notice Error thrown when the total number of signers is less than the threshold.
    /// @param totalSigners The current number of signers.
    /// @param threshold The required threshold.
    error TotalSignersLessThanThreshold(uint256 totalSigners, uint256 threshold);

    /// @notice Error thrown when attempting to add a signer who is already active.
    /// @param signer The address of the signer.
    error SignerAlreadyAdded(address signer);

    /// @notice Error thrown when attempting to remove a signer who is not found.
    /// @param signer The address of the signer.
    error SignerNotFound(address signer);

    /// @notice Error thrown when there is a signature format error or mismatch in length.
    error SignatureError();

    /// @notice Error thrown when signers are not sorted in ascending order (prevents duplicates).
    error UnsortedSigners();

    /**
     * @notice Emitted when a signer's active status is updated.
     * @param signer The address of the signer.
     * @param active True if added, false if removed.
     */
    event SignerSet(address indexed signer, bool active);

    /**
     * @notice Emitted when the threshold for signatures is set.
     * @param threshold The new threshold.
     */
    event ThresholdSet(uint256 threshold);

    /**
     * @dev The length of a single signature in bytes (r=32, s=32, v=1).
     */
    uint8 constant SIGNATURE_LENGTH = 65;

    /**
     * @dev Initializes the MultiSig with a list of signers and sets the signature threshold.
     * @param _signers Array of signer addresses.
     * @param _threshold The initial threshold for signatures.
     */
    constructor(address[] memory _signers, uint256 _threshold) {
        for (uint256 i = 0; i < _signers.length; i++) {
            _addSigner(_signers[i]);
        }
        _setThreshold(_threshold);
    }

    /**
     * @notice Allows the MultiSig contract to update the signature threshold.
     * @dev This function can only be called by the MultiSig contract itself.
     * @param _threshold The new threshold value.
     */
    function setThreshold(uint256 _threshold) external onlySelfCall {
        _setThreshold(_threshold);
    }

    /**
     * @dev Internal function to set the threshold for this MultiSig.
     *      - The threshold must be greater than zero.
     *      - The threshold must be less than or equal to the number of signers.
     * @param _threshold The new threshold value.
     */
    function _setThreshold(uint256 _threshold) internal {
        if (_threshold == 0) revert ZeroThreshold();
        if (totalSigners() < _threshold) revert TotalSignersLessThanThreshold(totalSigners(), _threshold);

        threshold = _threshold;
        emit ThresholdSet(_threshold);
    }

    /**
     * @notice Adds or removes a signer from this MultiSig.
     * @dev Only callable via the MultiSig contract itself.
     * @param _signer The address of the signer to add/remove.
     * @param _active True to add signer, false to remove signer.
     */
    function setSigner(address _signer, bool _active) external onlySelfCall {
        if (_active) {
            _addSigner(_signer);
        } else {
            _removeSigner(_signer);
        }
    }

    /**
     * @dev Internal function to add a signer.
     *      - `address(0)` is not a valid signer.
     *      - A signer cannot be added twice.
     * @param _signer The address of the signer to add.
     */
    function _addSigner(address _signer) internal {
        if (_signer == address(0)) revert InvalidSigner();
        if (!signerSet.add(_signer)) revert SignerAlreadyAdded(_signer);

        emit SignerSet(_signer, true);
    }

    /**
     * @dev Internal function to remove a signer.
     *      - Signer must be part of the existing set of signers.
     *      - The threshold must be less than or equal to the number of remaining signers.
     * @param _signer The address of the signer to remove.
     */
    function _removeSigner(address _signer) internal {
        if (!signerSet.remove(_signer)) revert SignerNotFound(_signer);
        if (totalSigners() < threshold) revert TotalSignersLessThanThreshold(totalSigners(), threshold);

        emit SignerSet(_signer, false);
    }

    /**
     * @notice Verifies signatures on a given digest against the threshold.
     * @dev Verifies that exactly `threshold` signatures are present, sorted by ascending signer addresses.
     * @param _digest The message digest (hash) being signed.
     * @param _signatures The concatenated signatures.
     */
    function verifySignatures(bytes32 _digest, bytes calldata _signatures) public view {
        verifyNSignatures(_digest, _signatures, threshold);
    }

    /**
     * @notice Verifies N signatures on a given digest.
     * @dev Reverts if:
     *       - The threshold passed is zero.
     *       - The number of signatures doesn't match N (each signature is 65 bytes).
     *       - The signers are not strictly increasing (to prevent duplicates).
     *       - Any signer is not in the set of authorized signers.
     * @param _digest The message digest (hash) being signed.
     * @param _signatures The concatenated signatures.
     * @param _threshold The required number of valid signatures.
     */
    function verifyNSignatures(bytes32 _digest, bytes calldata _signatures, uint256 _threshold) public view {
        if (_threshold == 0) revert ZeroThreshold();
        // Each signature is SIGNATURE_LENGTH (65) bytes (r=32, s=32, v=1).
        if ((_signatures.length % SIGNATURE_LENGTH) != 0) revert SignatureError();
        uint256 signaturesCount = _signatures.length / SIGNATURE_LENGTH;
        if (signaturesCount < _threshold) revert SignatureError();

        // There cannot be a signer with address 0, so we start with address(0) to ensure ascending order.
        address lastSigner = address(0);

        for (uint256 i = 0; i < signaturesCount; i++) {
            // Extract a single signature (SIGNATURE_LENGTH (65) bytes) at a time.
            bytes calldata signature = _signatures[i * SIGNATURE_LENGTH:(i + 1) * SIGNATURE_LENGTH];
            address currentSigner = ECDSA.recover(_digest, signature);

            // Check ordering to avoid duplicates and ensure strictly increasing addresses.
            if (currentSigner <= lastSigner) revert UnsortedSigners();
            // Check if the signer is in our set.
            if (!isSigner(currentSigner)) revert SignerNotFound(currentSigner);
            lastSigner = currentSigner;
        }
    }

    /**
     * @notice Returns the list of all active signers.
     * @return An array of addresses representing the current set of signers.
     */
    function getSigners() public view returns (address[] memory) {
        return signerSet.values();
    }

    /**
     * @notice Checks if a given address is in the set of signers.
     * @param _signer The address to check.
     * @return True if the address is a signer, otherwise false.
     */
    function isSigner(address _signer) public view returns (bool) {
        return signerSet.contains(_signer);
    }

    /**
     * @notice Returns the total number of active signers.
     * @return The number of signers currently active.
     */
    function totalSigners() public view returns (uint256) {
        return signerSet.length();
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint64","name":"_oneSigId","type":"uint64"},{"internalType":"address[]","name":"_signers","type":"address[]"},{"internalType":"uint256","name":"_threshold","type":"uint256"},{"internalType":"address[]","name":"_executors","type":"address[]"},{"internalType":"bool","name":"_executorRequired","type":"bool"},{"internalType":"bytes32","name":"_seed","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ECDSAInvalidSignature","type":"error"},{"inputs":[{"internalType":"uint256","name":"length","type":"uint256"}],"name":"ECDSAInvalidSignatureLength","type":"error"},{"inputs":[{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"ECDSAInvalidSignatureS","type":"error"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"ExecutionFailed","type":"error"},{"inputs":[{"internalType":"address","name":"executor","type":"address"}],"name":"ExecutorAlreadyActive","type":"error"},{"inputs":[{"internalType":"address","name":"executor","type":"address"}],"name":"ExecutorNotFound","type":"error"},{"inputs":[],"name":"InvalidExecutor","type":"error"},{"inputs":[],"name":"InvalidProofOrNonce","type":"error"},{"inputs":[],"name":"InvalidSigner","type":"error"},{"inputs":[],"name":"MerkleRootExpired","type":"error"},{"inputs":[],"name":"OnlyExecutorOrSigner","type":"error"},{"inputs":[],"name":"OnlySelfCall","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[],"name":"SignatureError","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"}],"name":"SignerAlreadyAdded","type":"error"},{"inputs":[{"internalType":"address","name":"signer","type":"address"}],"name":"SignerNotFound","type":"error"},{"inputs":[{"internalType":"uint256","name":"totalSigners","type":"uint256"},{"internalType":"uint256","name":"threshold","type":"uint256"}],"name":"TotalSignersLessThanThreshold","type":"error"},{"inputs":[],"name":"UnsortedSigners","type":"error"},{"inputs":[],"name":"ZeroThreshold","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"required","type":"bool"}],"name":"ExecutorRequiredSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"executor","type":"address"},{"indexed":false,"internalType":"bool","name":"active","type":"bool"}],"name":"ExecutorSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"seed","type":"bytes32"}],"name":"SeedSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"signer","type":"address"},{"indexed":false,"internalType":"bool","name":"active","type":"bool"}],"name":"SignerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"threshold","type":"uint256"}],"name":"ThresholdSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes32","name":"merkleRoot","type":"bytes32"},{"indexed":false,"internalType":"uint256","name":"nonce","type":"uint256"}],"name":"TransactionExecuted","type":"event"},{"inputs":[],"name":"LEAF_ENCODING_VERSION","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ONE_SIG_ID","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_sender","type":"address"}],"name":"canExecuteTransaction","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint64","name":"_nonce","type":"uint64"},{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct OneSig.Call[]","name":"_calls","type":"tuple[]"}],"name":"encodeLeaf","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct OneSig.Call[]","name":"calls","type":"tuple[]"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"internalType":"struct OneSig.Transaction","name":"_transaction","type":"tuple"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"_expiry","type":"uint256"},{"internalType":"bytes","name":"_signatures","type":"bytes"}],"name":"executeTransaction","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"executorRequired","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getExecutors","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getSigners","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_executor","type":"address"}],"name":"isExecutor","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_signer","type":"address"}],"name":"isSigner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nonce","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"seed","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_executor","type":"address"},{"internalType":"bool","name":"_active","type":"bool"}],"name":"setExecutor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_executorRequired","type":"bool"}],"name":"setExecutorRequired","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_seed","type":"bytes32"}],"name":"setSeed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signer","type":"address"},{"internalType":"bool","name":"_active","type":"bool"}],"name":"setSigner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_threshold","type":"uint256"}],"name":"setThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"threshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalExecutors","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSigners","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"uint256","name":"_expiry","type":"uint256"},{"internalType":"bytes","name":"_signatures","type":"bytes"}],"name":"verifyMerkleRoot","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_digest","type":"bytes32"},{"internalType":"bytes","name":"_signatures","type":"bytes"},{"internalType":"uint256","name":"_threshold","type":"uint256"}],"name":"verifyNSignatures","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_digest","type":"bytes32"},{"internalType":"bytes","name":"_signatures","type":"bytes"}],"name":"verifySignatures","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"components":[{"components":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"internalType":"struct OneSig.Call[]","name":"calls","type":"tuple[]"},{"internalType":"bytes32[]","name":"proof","type":"bytes32[]"}],"internalType":"struct OneSig.Transaction","name":"_transaction","type":"tuple"}],"name":"verifyTransactionProof","outputs":[],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000000000000000000000000000000000000000762f00000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000300000000000000000000000000000000000000000000000000000000000001800000000000000000000000000000000000000000000000000000000000000001a8c6099081c03ac4c11ed511690f296077e94d44cf99bebc8c349cf972f8734000000000000000000000000000000000000000000000000000000000000000050000000000000000000000000cb72c1f6a36c225a7e2b21712e8853a4a1acc470000000000000000000000005bc6aa6ad117a8b50abf9e1658971f5da1968c5c00000000000000000000000073e9c017ad37e2113e709d8070cc9e1b28180e1e000000000000000000000000771dcacb96024d1e55fd21fe8a8187aa7ec9e77e000000000000000000000000e67db04d7eff4e9ec282ed929632d4ff058112d7000000000000000000000000000000000000000000000000000000000000000100000000000000000000000039f86ecef62c5bce23428d6b7c7050d9ecb0e346

-----Decoded View---------------
Arg [0] : _oneSigId (uint64): 30255
Arg [1] : _signers (address[]): 0x0cb72C1F6a36c225A7E2B21712E8853A4A1acc47,0x5bC6AA6ad117A8B50ABf9E1658971f5DA1968c5c,0x73E9c017Ad37e2113e709D8070Cc9E1b28180e1e,0x771dcAcB96024d1e55Fd21Fe8a8187AA7EC9e77e,0xe67DB04d7eFF4e9ec282eD929632D4FF058112d7
Arg [2] : _threshold (uint256): 3
Arg [3] : _executors (address[]): 0x39f86ECef62c5bcE23428d6b7c7050D9Ecb0e346
Arg [4] : _executorRequired (bool): True
Arg [5] : _seed (bytes32): 0xa8c6099081c03ac4c11ed511690f296077e94d44cf99bebc8c349cf972f87340

-----Encoded View---------------
14 Constructor Arguments found :
Arg [0] : 000000000000000000000000000000000000000000000000000000000000762f
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [5] : a8c6099081c03ac4c11ed511690f296077e94d44cf99bebc8c349cf972f87340
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 0000000000000000000000000cb72c1f6a36c225a7e2b21712e8853a4a1acc47
Arg [8] : 0000000000000000000000005bc6aa6ad117a8b50abf9e1658971f5da1968c5c
Arg [9] : 00000000000000000000000073e9c017ad37e2113e709d8070cc9e1b28180e1e
Arg [10] : 000000000000000000000000771dcacb96024d1e55fd21fe8a8187aa7ec9e77e
Arg [11] : 000000000000000000000000e67db04d7eff4e9ec282ed929632d4ff058112d7
Arg [12] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [13] : 00000000000000000000000039f86ecef62c5bce23428d6b7c7050d9ecb0e346

755:11011:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3074:210:4;;;;;;;;;;-1:-1:-1;3074:210:4;;;;;:::i;:::-;;:::i;:::-;;8937:591:6;;;;;;;;;;-1:-1:-1;8937:591:6;;;;;:::i;:::-;;:::i;4133:198:5:-;;;;;;;;;;-1:-1:-1;4133:198:5;;;;;:::i;:::-;;:::i;6842:92:6:-;;;;;;;;;;-1:-1:-1;6842:92:6;;;;;:::i;:::-;;:::i;891:24:5:-;;;;;;;;;;;;;;;;;;;1849:25:8;;;1837:2;1822:18;891:24:5;;;;;;;;927:47:6;;;;;;;;;;;;973:1;927:47;;;;;2057:4:8;2045:17;;;2027:36;;2015:2;2000:18;927:47:6;1885:184:8;724:28:4;;;;;;;;;;-1:-1:-1;724:28:4;;;;;;;;;;;2239:14:8;;2232:22;2214:41;;2202:2;2187:18;724:28:4;2074:187:8;6375:1268:5;;;;;;;;;;-1:-1:-1;6375:1268:5;;;;;:::i;:::-;;:::i;3129:19:6:-;;;;;;;;;;;;;;;;8099:113:5;;;;;;;;;;-1:-1:-1;8099:113:5;;;;;:::i;:::-;;:::i;7580:995:6:-;;;;;;:::i;:::-;;:::i;7798:103:5:-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;3187:106::-;;;;;;;;;;-1:-1:-1;3187:106:5;;;;;:::i;:::-;;:::i;3265:19:6:-;;;;;;;;;;-1:-1:-1;3265:19:6;;;;-1:-1:-1;;;;;3265:19:6;;;;;;-1:-1:-1;;;;;5177:31:8;;;5159:50;;5147:2;5132:18;3265:19:6;5015:200:8;10469:604:6;;;;;;;;;;-1:-1:-1;10469:604:6;;;;;:::i;:::-;;:::i;5662:150:5:-;;;;;;;;;;-1:-1:-1;5662:150:5;;;;;:::i;:::-;;:::i;2336:131:4:-;;;;;;;;;;-1:-1:-1;2336:131:4;;;;;:::i;:::-;;:::i;8348:96:5:-;;;;;;;;;;;;;:::i;9886:307:6:-;;;;;;;;;;-1:-1:-1;9886:307:6;;;;;:::i;:::-;;:::i;4453:121:4:-;;;;;;;;;;-1:-1:-1;4453:121:4;;;;;:::i;:::-;;:::i;11314:301:6:-;;;;;;;;;;-1:-1:-1;11314:301:6;;;;;:::i;:::-;;:::i;2896:34::-;;;;;;;;;;;;;;;4142:107:4;;;;;;;;;;;;;:::i;4714:100::-;;;;;;;;;;;;;:::i;880:40:6:-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;880:40:6;;;;;;;;;;;;:::i;3074:210:4:-;365:10:7;387:4;365:27;361:54;;401:14;;-1:-1:-1;;;;;;401:14:7;;;;;;;;;;;361:54;3164:7:4::1;3160:118;;;3187:23;3200:9;3187:12;:23::i;:::-;3074:210:::0;;:::o;3160:118::-:1;3241:26;3257:9;3241:15;:26::i;8937:591:6:-:0;9097:7;9079:15;:25;9075:57;;;9113:19;;-1:-1:-1;;;9113:19:6;;;;;;;;;;;9075:57;9253:24;;;;;;;;;;;-1:-1:-1;;;9253:24:6;;;;;;;;2193:15;;;;;;;;;;-1:-1:-1;;;2193:15:6;;;;2265:7;;;;;;;;;;-1:-1:-1;;;2265:7:6;;;;2115:285;;1361:95;2115:285;;;8045:25:8;2183:26:6;8086:18:8;;;8079:34;2249:25:6;8129:18:8;;;8122:34;2303:1:6;8172:18:8;;;8165:45;2358:6:6;8226:19:8;;;;8219:61;;;;2115:285:6;;;;;;;;;;8017:19:8;;;2115:285:6;;2092:318;;;;;;9378:4;;2574:75;9339:66;;;8522:25:8;8563:18;;;8556:34;8606:18;;;8599:34;;;8649:18;;;;8642:34;;;9339:66:6;;;;;;;;;;8494:19:8;;;9339:66:6;;;9329:77;;;;;;;;;;-1:-1:-1;;9219:201:6;;9253:24;2092:318;9329:77;9219:201;;;:::i;:::-;;;;;;;;;;;;;9196:234;;;;;;9179:251;;9484:37;9501:6;9509:11;;9484:16;:37::i;:::-;9041:487;8937:591;;;;:::o;4133:198:5:-;365:10:7;387:4;365:27;361:54;;401:14;;-1:-1:-1;;;;;;401:14:7;;;;;;;;;;;361:54;4219:7:5::1;4215:110;;;4242:19;4253:7;4242:10;:19::i;4215:110::-;4292:22;4306:7;4292:13;:22::i;6842:92:6:-:0;365:10:7;387:4;365:27;361:54;;401:14;;-1:-1:-1;;;;;;401:14:7;;;;;;;;;;;361:54;6912:15:6::1;6921:5;6912:8;:15::i;:::-;6842:92:::0;:::o;6375:1268:5:-;6493:10;6507:1;6493:15;6489:43;;6517:15;;-1:-1:-1;;;6517:15:5;;;;;;;;;;;6489:43;6623:37;2522:2;6623:11;:37;:::i;:::-;6622:44;6618:73;;6675:16;;-1:-1:-1;;;6675:16:5;;;;;;;;;;;6618:73;6701:23;6727:37;2522:2;6727:11;:37;:::i;:::-;6701:63;;6796:10;6778:15;:28;6774:57;;;6815:16;;-1:-1:-1;;;6815:16:5;;;;;;;;;;;6774:57;6949:18;6996:9;6991:646;7015:15;7011:1;:19;6991:646;;;7134:24;;7161:11;;7173:20;2522:2;7173:1;:20;:::i;:::-;7161:60;2522:2;7195:5;:1;7199;7195:5;:::i;:::-;7194:26;;;;:::i;:::-;7161:60;;;;;;;:::i;:::-;7134:87;;;;7235:21;7259:33;7273:7;7282:9;;7259:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7259:13:5;;-1:-1:-1;;;7259:33:5:i;:::-;7235:57;;7420:10;-1:-1:-1;;;;;7403:27:5;:13;-1:-1:-1;;;;;7403:27:5;;7399:57;;7439:17;;-1:-1:-1;;;7439:17:5;;;;;;;;;;;7399:57;7525:23;7534:13;7525:8;:23::i;:::-;7520:66;;7557:29;;-1:-1:-1;;;7557:29:5;;-1:-1:-1;;;;;10453:32:8;;7557:29:5;;;10435:51:8;10408:18;;7557:29:5;;;;;;;;7520:66;7613:13;-1:-1:-1;;;7032:3:5;;6991:646;;;;6479:1164;;6375:1268;;;;:::o;8099:113::-;8155:4;8178:27;8155:4;8197:7;8178:18;:27::i;:::-;8171:34;8099:113;-1:-1:-1;;8099:113:5:o;7580:995:6:-;2356:21:0;:19;:21::i;:::-;5353:33:6::1;5375:10;5353:21;:33::i;:::-;5348:69;;5395:22;;-1:-1:-1::0;;;5395:22:6::1;;;;;;;;;;;5348:69;7863:51:::2;7880:11;7893:7;7902:11;;7863:16;:51::i;:::-;8007:49;8030:11;8043:12;8007:22;:49::i;:::-;8141:5;:7:::0;;8129:9:::2;::::0;-1:-1:-1;;;;;8141:7:6;;::::2;::::0;8129:9;8141:7:::2;::::0;::::2;:::i;:::-;;;;;;;;-1:-1:-1::0;;;;;8141:7:6::2;;;;;-1:-1:-1::0;;;;;8141:7:6::2;;;;;;-1:-1:-1::0;;;;;8129:19:6::2;;;8204:9;8199:319;8223:18;:12:::0;;:18:::2;:::i;:::-;:25;;8219:1;:29;8199:319;;;8270:12;8288:18;:12:::0;;:18:::2;:::i;:::-;8307:1;8288:21;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:24;::::0;::::2;::::0;::::2;::::0;::::2;:::i;:::-;-1:-1:-1::0;;;;;8288:29:6::2;8326:18;:12:::0;;:18:::2;:::i;:::-;8345:1;8326:21;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:27;;;8373:18;:12:::0;;:18:::2;:::i;:::-;8392:1;8373:21;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;:26;::::0;::::2;::::0;::::2;::::0;::::2;:::i;:::-;8288:125;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8269:144;;;8473:7;8468:39;;8489:18;::::0;-1:-1:-1;;;8489:18:6;;::::2;::::0;::::2;1849:25:8::0;;;1822:18;;8489::6::2;1703:177:8::0;8468:39:6::2;-1:-1:-1::0;8250:3:6::2;;8199:319;;;-1:-1:-1::0;8533:35:6::2;::::0;;12719:25:8;;;12775:2;12760:18;;12753:34;;;8533:35:6::2;::::0;12692:18:8;8533:35:6::2;;;;;;;7804:771;2398:20:0::0;1713:1;2924:7;:21;2744:208;7798:103:5;7841:16;7876:18;:9;:16;:18::i;:::-;7869:25;;7798:103;:::o;3187:106::-;365:10:7;387:4;365:27;361:54;;401:14;;-1:-1:-1;;;;;;401:14:7;;;;;;;;;;;361:54;3261:25:5::1;3275:10;3261:13;:25::i;10469:604:6:-:0;10549:7;973:1;10784:10;10856:4;-1:-1:-1;;;;;10832:31:6;10824:40;;10932:6;10979;;10968:18;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;10968:18:6;;;;;;;;;;10687:325;;;;;;10968:18;10687:325;;:::i;:::-;;;;-1:-1:-1;;10687:325:6;;;;;;;;;10652:382;;10687:325;10652:382;;;;10614:438;;;15507:19:8;15542:12;10614:438:6;;;;;;;;;;;;10587:479;;;;;;10568:498;;10469:604;;;;;:::o;5662:150:5:-;5755:50;5773:7;5782:11;;5795:9;;5755:17;:50::i;:::-;5662:150;;;:::o;2336:131:4:-;365:10:7;387:4;365:27;361:54;;401:14;;-1:-1:-1;;;;;;401:14:7;;;;;;;;;;;361:54;2421:39:4::1;2442:17;2421:20;:39::i;8348:96:5:-:0;8393:7;8419:18;:9;:16;:18::i;9886:307:6:-;10022:5;;9996:12;;10011:37;;-1:-1:-1;;;;;10022:5:6;10029:18;:12;;:18;:::i;10011:37::-;9996:52;-1:-1:-1;10058:10:6;10071:65;10098:18;;;;:12;:18;:::i;:::-;10118:11;10131:4;10071:26;:65::i;:::-;10058:78;;10151:5;10146:40;;10165:21;;-1:-1:-1;;;10165:21:6;;;;;;;;;;;10146:40;9986:207;;9886:307;;:::o;4453:121:4:-;4513:4;4536:31;:11;4557:9;4536:20;:31::i;11314:301:6:-;11547:16;;11383:4;;11547:16;;11546:17;;:40;;;11567:19;11578:7;11567:10;:19::i;:::-;11546:61;;;;11590:17;11599:7;11590:8;:17::i;4142:107:4:-;4187:16;4222:20;:11;:18;:20::i;4714:100::-;4761:7;4787:20;:11;:18;:20::i;3416:245::-;-1:-1:-1;;;;;3480:23:4;;3476:53;;3512:17;;-1:-1:-1;;;3512:17:4;;;;;;;;;;;3476:53;3544:26;:11;3560:9;3544:15;:26::i;:::-;3539:72;;3579:32;;-1:-1:-1;;;3579:32:4;;-1:-1:-1;;;;;10453:32:8;;3579::4;;;10435:51:8;10408:18;;3579:32:4;10289:203:8;3539:72:4;3626:28;;3649:4;2214:41:8;;-1:-1:-1;;;;;3626:28:4;;;;;2202:2:8;2187:18;3626:28:4;;;;;;;;3416:245;:::o;3799:184::-;3867:29;:11;3886:9;3867:18;:29::i;:::-;3862:70;;3905:27;;-1:-1:-1;;;3905:27:4;;-1:-1:-1;;;;;10453:32:8;;3905:27:4;;;10435:51:8;10408:18;;3905:27:4;10289:203:8;3862:70:4;3947:29;;3970:5;2214:41:8;;-1:-1:-1;;;;;3947:29:4;;;;;2202:2:8;2187:18;3947:29:4;2074:187:8;4552:225:5;-1:-1:-1;;;;;4612:21:5;;4608:49;;4642:15;;-1:-1:-1;;;4642:15:5;;;;;;;;;;;4608:49;4672:22;:9;4686:7;4672:13;:22::i;:::-;4667:63;;4703:27;;-1:-1:-1;;;4703:27:5;;-1:-1:-1;;;;;10453:32:8;;4703:27:5;;;10435:51:8;10408:18;;4703:27:5;10289:203:8;4667:63:5;4746:24;;4765:4;2214:41:8;;-1:-1:-1;;;;;4746:24:5;;;;;2202:2:8;2187:18;4746:24:5;2074:187:8;5065:274:5;5129:25;:9;5146:7;5129:16;:25::i;:::-;5124:62;;5163:23;;-1:-1:-1;;;5163:23:5;;-1:-1:-1;;;;;10453:32:8;;5163:23:5;;;10435:51:8;10408:18;;5163:23:5;10289:203:8;5124:62:5;5217:9;;5200:14;:12;:14::i;:::-;:26;5196:95;;;5265:14;:12;:14::i;:::-;5281:9;;5235:56;;-1:-1:-1;;;5235:56:5;;;;;12719:25:8;;;;12760:18;;;12753:34;12692:18;;5235:56:5;12545:248:8;5196:95:5;5307:25;;5326:5;2214:41:8;;-1:-1:-1;;;;;5307:25:5;;;;;2202:2:8;2187:18;5307:25:5;2074:187:8;6526:108:6;6586:4;:12;;;6613:14;;1849:25:8;;;6613:14:6;;1837:2:8;1822:18;6613:14:6;;;;;;;;6526:108;:::o;3702:255:1:-;3780:7;3800:17;3819:18;3839:16;3859:27;3870:4;3876:9;3859:10;:27::i;:::-;3799:87;;;;;;3896:28;3908:5;3915:8;3896:11;:28::i;:::-;-1:-1:-1;3941:9:1;;3702:255;-1:-1:-1;;;;3702:255:1:o;8871:165:3:-;-1:-1:-1;;;;;9004:23:3;;8951:4;4360:21;;;:14;;;:21;;;;;;:26;;8974:55;8967:62;8871:165;-1:-1:-1;;;8871:165:3:o;2431:307:0:-;1755:1;2558:7;;:18;2554:86;;2599:30;;-1:-1:-1;;;2599:30:0;;;;;;;;;;;2554:86;1755:1;2714:7;:17;2431:307::o;10270:300:3:-;10333:16;10361:22;10386:19;10394:3;10386:7;:19::i;3571:291:5:-;3637:10;3651:1;3637:15;3633:43;;3661:15;;-1:-1:-1;;;3661:15:5;;;;;;;;;;;3633:43;3707:10;3690:14;:12;:14::i;:::-;:27;3686:97;;;3756:14;:12;:14::i;:::-;3726:57;;-1:-1:-1;;;3726:57:5;;;;;12719:25:8;;;;12760:18;;;12753:34;;;12692:18;;3726:57:5;12545:248:8;3686:97:5;3794:9;:22;;;3831:24;;1849:25:8;;;3831:24:5;;1837:2:8;1822:18;3831:24:5;1703:177:8;2623:169:4;2696:16;:36;;-1:-1:-1;;2696:36:4;;;;;;;;;;2747:38;;2214:41:8;;;2747:38:4;;2202:2:8;2187:18;2747:38:4;2074:187:8;9117:115:3;9180:7;9206:19;9214:3;4556:18;;4474:107;1482:172:2;1583:4;1643;1606:33;1627:5;;1634:4;1606:20;:33::i;:::-;:41;;1482:172;-1:-1:-1;;;;;1482:172:2:o;8316:150:3:-;8386:4;8409:50;8414:3;-1:-1:-1;;;;;8434:23:3;;8409:4;:50::i;8634:156::-;8707:4;8730:53;8738:3;-1:-1:-1;;;;;8758:23:3;;8730:7;:53::i;2129:766:1:-;2210:7;2219:12;2233:7;2256:9;:16;2276:2;2256:22;2252:637;;2592:4;2577:20;;2571:27;2641:4;2626:20;;2620:27;2698:4;2683:20;;2677:27;2294:9;2669:36;2739:25;2750:4;2669:36;2571:27;2620;2739:10;:25::i;:::-;2732:32;;;;;;;;;;;2252:637;-1:-1:-1;;2860:16:1;;2811:1;;-1:-1:-1;2815:35:1;;2252:637;2129:766;;;;;:::o;7196:532::-;7291:20;7282:5;:29;;;;;;;;:::i;:::-;;7278:444;;7196:532;;:::o;7278:444::-;7387:29;7378:5;:38;;;;;;;;:::i;:::-;;7374:348;;7439:23;;-1:-1:-1;;;7439:23:1;;;;;;;;;;;7374:348;7492:35;7483:5;:44;;;;;;;;:::i;:::-;;7479:243;;7550:46;;-1:-1:-1;;;7550:46:1;;;;;1849:25:8;;;1822:18;;7550:46:1;1703:177:8;7479:243:1;7626:30;7617:5;:39;;;;;;;;:::i;:::-;;7613:109;;7679:32;;-1:-1:-1;;;7679:32:1;;;;;1849:25:8;;;1822:18;;7679:32:1;1703:177:8;5581:109:3;5637:16;5672:3;:11;;5665:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5581:109;;;:::o;2326:300:2:-;2419:7;2461:4;2419:7;2475:116;2495:16;;;2475:116;;;2547:33;2557:12;2571:5;;2577:1;2571:8;;;;;;;:::i;:::-;;;;;;;2547:9;:33::i;:::-;2532:48;-1:-1:-1;2513:3:2;;2475:116;;;-1:-1:-1;2607:12:2;2326:300;-1:-1:-1;;;;2326:300:2:o;2241:406:3:-;2304:4;4360:21;;;:14;;;:21;;;;;;2320:321;;-1:-1:-1;2362:23:3;;;;;;;;:11;:23;;;;;;;;;;;;;2544:18;;2520:21;;;:14;;;:21;;;;;;:42;;;;2576:11;;2320:321;-1:-1:-1;2625:5:3;2618:12;;2815:1368;2881:4;3010:21;;;:14;;;:21;;;;;;3046:13;;3042:1135;;3413:18;3434:12;3445:1;3434:8;:12;:::i;:::-;3480:18;;3413:33;;-1:-1:-1;3460:17:3;;3480:22;;3501:1;;3480:22;:::i;:::-;3460:42;;3535:9;3521:10;:23;3517:378;;3564:17;3584:3;:11;;3596:9;3584:22;;;;;;;;:::i;:::-;;;;;;;;;3564:42;;3731:9;3705:3;:11;;3717:10;3705:23;;;;;;;;:::i;:::-;;;;;;;;;;;;:35;;;;3844:25;;;:14;;;:25;;;;;:36;;;3517:378;3973:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;4076:3;:14;;:21;4091:5;4076:21;;;;;;;;;;;4069:28;;;4119:4;4112:11;;;;;;;3042:1135;4161:5;4154:12;;;;;5140:1530:1;5266:7;;;6199:66;6186:79;;6182:164;;;-1:-1:-1;6297:1:1;;-1:-1:-1;6301:30:1;;-1:-1:-1;6333:1:1;6281:54;;6182:164;6457:24;;;6440:14;6457:24;;;;;;;;;16992:25:8;;;17065:4;17053:17;;17033:18;;;17026:45;;;;17087:18;;;17080:34;;;17130:18;;;17123:34;;;6457:24:1;;16964:19:8;;6457:24:1;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6457:24:1;;-1:-1:-1;;6457:24:1;;;-1:-1:-1;;;;;;;6495:20:1;;6491:113;;-1:-1:-1;6547:1:1;;-1:-1:-1;6551:29:1;;-1:-1:-1;6547:1:1;;-1:-1:-1;6531:62:1;;6491:113;6622:6;-1:-1:-1;6630:20:1;;-1:-1:-1;6630:20:1;;-1:-1:-1;5140:1530:1;;;;;;;;;:::o;9229:147:2:-;9292:7;9322:1;9318;:5;:51;;9564:13;9655:15;;;9690:4;9683:15;;;9736:4;9720:21;;9318:51;;;9564:13;9655:15;;;9690:4;9683:15;;;9736:4;9720:21;;9326:20;9496:261;14:173:8;82:20;;-1:-1:-1;;;;;131:31:8;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:160::-;257:20;;313:13;;306:21;296:32;;286:60;;342:1;339;332:12;357:254;422:6;430;483:2;471:9;462:7;458:23;454:32;451:52;;;499:1;496;489:12;451:52;522:29;541:9;522:29;:::i;:::-;512:39;;570:35;601:2;590:9;586:18;570:35;:::i;:::-;560:45;;357:254;;;;;:::o;616:347::-;667:8;677:6;731:3;724:4;716:6;712:17;708:27;698:55;;749:1;746;739:12;698:55;-1:-1:-1;772:20:8;;-1:-1:-1;;;;;804:30:8;;801:50;;;847:1;844;837:12;801:50;884:4;876:6;872:17;860:29;;936:3;929:4;920:6;912;908:19;904:30;901:39;898:59;;;953:1;950;943:12;898:59;616:347;;;;;:::o;968:545::-;1056:6;1064;1072;1080;1133:2;1121:9;1112:7;1108:23;1104:32;1101:52;;;1149:1;1146;1139:12;1101:52;1185:9;1172:23;1162:33;;1242:2;1231:9;1227:18;1214:32;1204:42;;1297:2;1286:9;1282:18;1269:32;-1:-1:-1;;;;;1316:6:8;1313:30;1310:50;;;1356:1;1353;1346:12;1310:50;1395:58;1445:7;1436:6;1425:9;1421:22;1395:58;:::i;:::-;968:545;;;;-1:-1:-1;1472:8:8;-1:-1:-1;;;;968:545:8:o;1518:180::-;1577:6;1630:2;1618:9;1609:7;1605:23;1601:32;1598:52;;;1646:1;1643;1636:12;1598:52;-1:-1:-1;1669:23:8;;1518:180;-1:-1:-1;1518:180:8:o;2266:545::-;2354:6;2362;2370;2378;2431:2;2419:9;2410:7;2406:23;2402:32;2399:52;;;2447:1;2444;2437:12;2399:52;2483:9;2470:23;2460:33;;2544:2;2533:9;2529:18;2516:32;-1:-1:-1;;;;;2563:6:8;2560:30;2557:50;;;2603:1;2600;2593:12;2557:50;2642:58;2692:7;2683:6;2672:9;2668:22;2642:58;:::i;:::-;2266:545;;2719:8;;-1:-1:-1;2616:84:8;;2801:2;2786:18;2773:32;;2266:545;-1:-1:-1;;;;2266:545:8:o;2998:186::-;3057:6;3110:2;3098:9;3089:7;3085:23;3081:32;3078:52;;;3126:1;3123;3116:12;3078:52;3149:29;3168:9;3149:29;:::i;3189:159::-;3253:5;3298:2;3289:6;3284:3;3280:16;3276:25;3273:45;;;3314:1;3311;3304:12;3273:45;-1:-1:-1;3336:6:8;3189:159;-1:-1:-1;3189:159:8:o;3353:809::-;3481:6;3489;3497;3505;3513;3566:3;3554:9;3545:7;3541:23;3537:33;3534:53;;;3583:1;3580;3573:12;3534:53;3623:9;3610:23;-1:-1:-1;;;;;3693:2:8;3685:6;3682:14;3679:34;;;3709:1;3706;3699:12;3679:34;3732:71;3795:7;3786:6;3775:9;3771:22;3732:71;:::i;:::-;3722:81;;3850:2;3839:9;3835:18;3822:32;3812:42;;3901:2;3890:9;3886:18;3873:32;3863:42;;3958:2;3947:9;3943:18;3930:32;3914:48;;3987:2;3977:8;3974:16;3971:36;;;4003:1;4000;3993:12;3971:36;;4042:60;4094:7;4083:8;4072:9;4068:24;4042:60;:::i;:::-;3353:809;;;;-1:-1:-1;3353:809:8;;-1:-1:-1;4121:8:8;;4016:86;3353:809;-1:-1:-1;;;3353:809:8:o;4167:658::-;4338:2;4390:21;;;4460:13;;4363:18;;;4482:22;;;4309:4;;4338:2;4561:15;;;;4535:2;4520:18;;;4309:4;4604:195;4618:6;4615:1;4612:13;4604:195;;;4683:13;;-1:-1:-1;;;;;4679:39:8;4667:52;;4774:15;;;;4739:12;;;;4715:1;4633:9;4604:195;;;-1:-1:-1;4816:3:8;;4167:658;-1:-1:-1;;;;;;4167:658:8:o;5220:795::-;5338:6;5346;5354;5407:2;5395:9;5386:7;5382:23;5378:32;5375:52;;;5423:1;5420;5413:12;5375:52;5462:9;5449:23;-1:-1:-1;;;;;5549:2:8;5542:5;5538:14;5531:5;5528:25;5518:53;;5567:1;5564;5557:12;5518:53;5590:5;;-1:-1:-1;5646:2:8;5631:18;;5618:32;;5662:14;;;5659:34;;;5689:1;5686;5679:12;5659:34;5727:6;5716:9;5712:22;5702:32;;5772:7;5765:4;5761:2;5757:13;5753:27;5743:55;;5794:1;5791;5784:12;5743:55;5834:2;5821:16;5860:2;5852:6;5849:14;5846:34;;;5876:1;5873;5866:12;5846:34;5929:7;5924:2;5914:6;5911:1;5907:14;5903:2;5899:23;5895:32;5892:45;5889:65;;;5950:1;5947;5940:12;5889:65;5981:2;5977;5973:11;5963:21;;6003:6;5993:16;;;;;5220:795;;;;;:::o;6020:477::-;6099:6;6107;6115;6168:2;6156:9;6147:7;6143:23;6139:32;6136:52;;;6184:1;6181;6174:12;6136:52;6220:9;6207:23;6197:33;;6281:2;6270:9;6266:18;6253:32;-1:-1:-1;;;;;6300:6:8;6297:30;6294:50;;;6340:1;6337;6330:12;6294:50;6379:58;6429:7;6420:6;6409:9;6405:22;6379:58;:::i;:::-;6020:477;;6456:8;;-1:-1:-1;6353:84:8;;-1:-1:-1;;;;6020:477:8:o;6502:180::-;6558:6;6611:2;6599:9;6590:7;6586:23;6582:32;6579:52;;;6627:1;6624;6617:12;6579:52;6650:26;6666:9;6650:26;:::i;6687:432::-;6786:6;6794;6847:2;6835:9;6826:7;6822:23;6818:32;6815:52;;;6863:1;6860;6853:12;6815:52;6899:9;6886:23;6876:33;;6960:2;6949:9;6945:18;6932:32;-1:-1:-1;;;;;6979:6:8;6976:30;6973:50;;;7019:1;7016;7009:12;6973:50;7042:71;7105:7;7096:6;7085:9;7081:22;7042:71;:::i;:::-;7032:81;;;6687:432;;;;;:::o;7124:250::-;7209:1;7219:113;7233:6;7230:1;7227:13;7219:113;;;7309:11;;;7303:18;7290:11;;;7283:39;7255:2;7248:10;7219:113;;;-1:-1:-1;;7366:1:8;7348:16;;7341:27;7124:250::o;7379:396::-;7528:2;7517:9;7510:21;7491:4;7560:6;7554:13;7603:6;7598:2;7587:9;7583:18;7576:34;7619:79;7691:6;7686:2;7675:9;7671:18;7666:2;7658:6;7654:15;7619:79;:::i;:::-;7759:2;7738:15;-1:-1:-1;;7734:29:8;7719:45;;;;7766:2;7715:54;;7379:396;-1:-1:-1;;7379:396:8:o;8687:452::-;8874:3;8912:6;8906:13;8928:66;8987:6;8982:3;8975:4;8967:6;8963:17;8928:66;:::i;:::-;9016:16;;;;9041:21;;;-1:-1:-1;9089:4:8;9078:16;;9071:32;9130:2;9119:14;;8687:452;-1:-1:-1;8687:452:8:o;9144:127::-;9205:10;9200:3;9196:20;9193:1;9186:31;9236:4;9233:1;9226:15;9260:4;9257:1;9250:15;9276:112;9308:1;9334;9324:35;;9339:18;;:::i;:::-;-1:-1:-1;9373:9:8;;9276:112::o;9393:127::-;9454:10;9449:3;9445:20;9442:1;9435:31;9485:4;9482:1;9475:15;9509:4;9506:1;9499:15;9525:120;9565:1;9591;9581:35;;9596:18;;:::i;:::-;-1:-1:-1;9630:9:8;;9525:120::o;9650:168::-;9723:9;;;9754;;9771:15;;;9765:22;;9751:37;9741:71;;9792:18;;:::i;9823:125::-;9888:9;;;9909:10;;;9906:36;;;9922:18;;:::i;9953:331::-;10058:9;10069;10111:8;10099:10;10096:24;10093:44;;;10133:1;10130;10123:12;10093:44;10162:6;10152:8;10149:20;10146:40;;;10182:1;10179;10172:12;10146:40;-1:-1:-1;;10208:23:8;;;10253:25;;;;;-1:-1:-1;9953:331:8:o;10497:209::-;10535:3;-1:-1:-1;;;;;10616:2:8;10609:5;10605:14;10643:2;10634:7;10631:15;10628:41;;10649:18;;:::i;:::-;10698:1;10685:15;;10497:209;-1:-1:-1;;;10497:209:8:o;10711:569::-;10828:4;10834:6;10894:11;10881:25;10988:2;10984:7;10973:8;10957:14;10953:29;10949:43;10929:18;10925:68;10915:96;;11007:1;11004;10997:12;10915:96;11034:33;;11086:20;;;-1:-1:-1;;;;;;11118:30:8;;11115:50;;;11161:1;11158;11151:12;11115:50;11194:4;11182:17;;-1:-1:-1;11245:1:8;11241:14;;;11225;11221:35;11211:46;;11208:66;;;11270:1;11267;11260:12;11285:127;11346:10;11341:3;11337:20;11334:1;11327:31;11377:4;11374:1;11367:15;11401:4;11398:1;11391:15;11417:321;11507:4;11565:11;11552:25;11659:2;11655:7;11644:8;11628:14;11624:29;11620:43;11600:18;11596:68;11586:96;;11678:1;11675;11668:12;11586:96;11699:33;;;;;11417:321;-1:-1:-1;;11417:321:8:o;11743:521::-;11820:4;11826:6;11886:11;11873:25;11980:2;11976:7;11965:8;11949:14;11945:29;11941:43;11921:18;11917:68;11907:96;;11999:1;11996;11989:12;11907:96;12026:33;;12078:20;;;-1:-1:-1;;;;;;12110:30:8;;12107:50;;;12153:1;12150;12143:12;12107:50;12186:4;12174:17;;-1:-1:-1;12217:14:8;12213:27;;;12203:38;;12200:58;;;12254:1;12251;12244:12;12269:271;12452:6;12444;12439:3;12426:33;12408:3;12478:16;;12503:13;;;12478:16;12269:271;-1:-1:-1;12269:271:8:o;12798:1909::-;13025:2;13077:21;;;13050:18;;;13133:22;;;12996:4;;13174:2;13192:18;;;13256:1;13252:14;;;13237:30;;13233:39;;13295:6;12996:4;13329:1349;13343:6;13340:1;13337:13;13329:1349;;;13408:22;;;-1:-1:-1;;13404:36:8;13392:49;;13480:20;;13555:14;13551:27;;;-1:-1:-1;;13547:41:8;13523:66;;13513:94;;13603:1;13600;13593:12;13513:94;13633:31;;13687:4;-1:-1:-1;;;;;13723:25:8;13633:31;13723:25;:::i;:::-;13719:51;13711:6;13704:67;13832:2;13825:5;13821:14;13808:28;13803:2;13795:6;13791:15;13784:53;13902:2;13895:5;13891:14;13878:28;13991:2;13987:7;13979:5;13963:14;13959:26;13955:40;13933:20;13929:67;13919:95;;14010:1;14007;14000:12;13919:95;14042:32;;;14150:16;;;;-1:-1:-1;14101:21:8;-1:-1:-1;;;;;14182:30:8;;14179:50;;;14225:1;14222;14215:12;14179:50;14278:6;14262:14;14258:27;14249:7;14245:41;14242:61;;;14299:1;14296;14289:12;14242:61;14340:2;14335;14327:6;14323:15;14316:27;14380:6;14375:2;14367:6;14363:15;14356:31;14410:3;14400:13;;14465:6;14456:7;14451:2;14443:6;14439:15;14426:46;14522:1;14496:19;;;14492:28;;14485:39;14656:12;;;;14588:2;14567:15;-1:-1:-1;;14563:29:8;14551:42;;;14547:51;;;;-1:-1:-1;14621:15:8;;;;13365:1;13358:9;13329:1349;;;-1:-1:-1;14695:6:8;;12798:1909;-1:-1:-1;;;;;;;;12798:1909:8:o;14712:661::-;15006:3;15001;14997:13;14988:6;14983:3;14979:16;14975:36;14970:3;14963:49;14945:3;-1:-1:-1;;;;;15035:3:8;15031:28;15110:2;15101:6;15096:3;15092:16;15088:25;15084:1;15079:3;15075:11;15068:46;15143:6;15139:1;15134:3;15130:11;15123:27;15202:2;15193:6;15188:3;15184:16;15180:25;15175:2;15170:3;15166:12;15159:47;;15235:6;15229:13;15251:75;15319:6;15314:2;15309:3;15305:12;15298:4;15290:6;15286:17;15251:75;:::i;:::-;15346:16;;;;15364:2;15342:25;;14712:661;-1:-1:-1;;;;;;14712:661:8:o;16368:127::-;16429:10;16424:3;16420:20;16417:1;16410:31;16460:4;16457:1;16450:15;16484:4;16481:1;16474:15;16500:128;16567:9;;;16588:11;;;16585:37;;;16602:18;;:::i;16633:127::-;16694:10;16689:3;16685:20;16682:1;16675:31;16725:4;16722:1;16715:15;16749:4;16746:1;16739:15

ipfs://9946885046aa71e95b82d42220073304909ffb06ef88e120984dfeb032c709c7