/**
 *Submitted for verification at Etherscan.io on 2025-06-03
*/

/**
 *Submitted for verification at Etherscan.io on 2025-04-04
*/

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity =0.8.19 >=0.8.0 ^0.8.19 ^0.8.4;

// lib/solady/src/auth/Ownable.sol

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev An ownership handover to `pendingOwner` has been requested.
    event OwnershipHandoverRequested(address indexed pendingOwner);

    /// @dev The ownership handover to `pendingOwner` has been canceled.
    event OwnershipHandoverCanceled(address indexed pendingOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev `keccak256(bytes("OwnershipHandoverRequested(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE =
        0xdbf36a107da19e49527a7176a1babf963b4b0ff8cde35ee35d6cd8f1f9ac7e1d;

    /// @dev `keccak256(bytes("OwnershipHandoverCanceled(address)"))`.
    uint256 private constant _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE =
        0xfa7b8eab7da67f412cc9575ed43464468f9bfbae89d1675917346ca6d8fe3c92;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The owner slot is given by: `not(_OWNER_SLOT_NOT)`.
    /// It is intentionally chosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    uint256 private constant _OWNER_SLOT_NOT = 0x8b78c6d8;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     INTERNAL FUNCTIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Clean the upper 96 bits.
            newOwner := shr(96, shl(96, newOwner))
            // Store the new value.
            sstore(not(_OWNER_SLOT_NOT), newOwner)
            // Emit the {OwnershipTransferred} event.
            log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            let ownerSlot := not(_OWNER_SLOT_NOT)
            // Clean the upper 96 bits.
            newOwner := shr(96, shl(96, newOwner))
            // Emit the {OwnershipTransferred} event.
            log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
            // Store the new value.
            sstore(ownerSlot, newOwner)
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(not(_OWNER_SLOT_NOT)))) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns how long a two-step ownership handover is valid for in seconds.
    /// Override to return a different value if needed.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ownershipHandoverValidFor() internal view virtual returns (uint64) {
        return 48 * 3600;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to transfer the ownership to `newOwner`.
    function transferOwnership(address newOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(shl(96, newOwner)) {
                mstore(0x00, 0x7448fbae) // `NewOwnerIsZeroAddress()`.
                revert(0x1c, 0x04)
            }
        }
        _setOwner(newOwner);
    }

    /// @dev Allows the owner to renounce their ownership.
    function renounceOwnership() public payable virtual onlyOwner {
        _setOwner(address(0));
    }

    /// @dev Request a two-step ownership handover to the caller.
    /// The request will automatically expire in 48 hours (172800 seconds) by default.
    function requestOwnershipHandover() public payable virtual {
        unchecked {
            uint256 expires = block.timestamp + _ownershipHandoverValidFor();
            /// @solidity memory-safe-assembly
            assembly {
                // Compute and set the handover slot to `expires`.
                mstore(0x0c, _HANDOVER_SLOT_SEED)
                mstore(0x00, caller())
                sstore(keccak256(0x0c, 0x20), expires)
                // Emit the {OwnershipHandoverRequested} event.
                log2(0, 0, _OWNERSHIP_HANDOVER_REQUESTED_EVENT_SIGNATURE, caller())
            }
        }
    }

    /// @dev Cancels the two-step ownership handover to the caller, if any.
    function cancelOwnershipHandover() public payable virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, caller())
            sstore(keccak256(0x0c, 0x20), 0)
            // Emit the {OwnershipHandoverCanceled} event.
            log2(0, 0, _OWNERSHIP_HANDOVER_CANCELED_EVENT_SIGNATURE, caller())
        }
    }

    /// @dev Allows the owner to complete the two-step ownership handover to `pendingOwner`.
    /// Reverts if there is no existing ownership handover requested by `pendingOwner`.
    function completeOwnershipHandover(address pendingOwner) public payable virtual onlyOwner {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute and set the handover slot to 0.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            let handoverSlot := keccak256(0x0c, 0x20)
            // If the handover does not exist, or has expired.
            if gt(timestamp(), sload(handoverSlot)) {
                mstore(0x00, 0x6f5e8818) // `NoHandoverRequest()`.
                revert(0x1c, 0x04)
            }
            // Set the handover slot to 0.
            sstore(handoverSlot, 0)
        }
        _setOwner(pendingOwner);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(not(_OWNER_SLOT_NOT))
        }
    }

    /// @dev Returns the expiry timestamp for the two-step ownership handover to `pendingOwner`.
    function ownershipHandoverExpiresAt(address pendingOwner)
        public
        view
        virtual
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the handover slot.
            mstore(0x0c, _HANDOVER_SLOT_SEED)
            mstore(0x00, pendingOwner)
            // Load the handover slot.
            result := sload(keccak256(0x0c, 0x20))
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MODIFIERS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}

// lib/solady/src/utils/SafeTransferLib.sol

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
///
/// @dev Note:
/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.
/// - For ERC20s, this implementation won't check that a token has code,
///   responsibility is delegated to the caller.
library SafeTransferLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The ETH transfer has failed.
    error ETHTransferFailed();

    /// @dev The ERC20 `transferFrom` has failed.
    error TransferFromFailed();

    /// @dev The ERC20 `transfer` has failed.
    error TransferFailed();

    /// @dev The ERC20 `approve` has failed.
    error ApproveFailed();

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.
    uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;

    /// @dev Suggested gas stipend for contract receiving ETH to perform a few
    /// storage reads and writes, but low enough to prevent griefing.
    uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ETH OPERATIONS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.
    //
    // The regular variants:
    // - Forwards all remaining gas to the target.
    // - Reverts if the target reverts.
    // - Reverts if the current contract has insufficient balance.
    //
    // The force variants:
    // - Forwards with an optional gas stipend
    //   (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).
    // - If the target reverts, or if the gas stipend is exhausted,
    //   creates a temporary contract to force send the ETH via `SELFDESTRUCT`.
    //   Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.
    // - Reverts if the current contract has insufficient balance.
    //
    // The try variants:
    // - Forwards with a mandatory gas stipend.
    // - Instead of reverting, returns whether the transfer succeeded.

    /// @dev Sends `amount` (in wei) ETH to `to`.
    function safeTransferETH(address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(call(gas(), to, amount, gas(), 0x00, gas(), 0x00)) {
                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Sends all the ETH in the current contract to `to`.
    function safeTransferAllETH(address to) internal {
        /// @solidity memory-safe-assembly
        assembly {
            // Transfer all the ETH and check if it succeeded or not.
            if iszero(call(gas(), to, selfbalance(), gas(), 0x00, gas(), 0x00)) {
                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if lt(selfbalance(), amount) {
                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                revert(0x1c, 0x04)
            }
            if iszero(call(gasStipend, to, amount, gas(), 0x00, gas(), 0x00)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                if iszero(create(amount, 0x0b, 0x16)) {
                    returndatacopy(gas(), returndatasize(), shr(20, gas())) // For gas estimation.
                }
            }
        }
    }

    /// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.
    function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(call(gasStipend, to, selfbalance(), gas(), 0x00, gas(), 0x00)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                if iszero(create(selfbalance(), 0x0b, 0x16)) {
                    returndatacopy(gas(), returndatasize(), shr(20, gas())) // For gas estimation.
                }
            }
        }
    }

    /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.
    function forceSafeTransferETH(address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if lt(selfbalance(), amount) {
                mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                revert(0x1c, 0x04)
            }
            if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, gas(), 0x00, gas(), 0x00)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                if iszero(create(amount, 0x0b, 0x16)) {
                    returndatacopy(gas(), returndatasize(), shr(20, gas())) // For gas estimation.
                }
            }
        }
    }

    /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.
    function forceSafeTransferAllETH(address to) internal {
        /// @solidity memory-safe-assembly
        assembly {
            if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), gas(), 0x00, gas(), 0x00)) {
                mstore(0x00, to) // Store the address in scratch space.
                mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                if iszero(create(selfbalance(), 0x0b, 0x16)) {
                    returndatacopy(gas(), returndatasize(), shr(20, gas())) // For gas estimation.
                }
            }
        }
    }

    /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
    function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
        internal
        returns (bool success)
    {
        /// @solidity memory-safe-assembly
        assembly {
            success := call(gasStipend, to, amount, gas(), 0x00, gas(), 0x00)
        }
    }

    /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.
    function trySafeTransferAllETH(address to, uint256 gasStipend)
        internal
        returns (bool success)
    {
        /// @solidity memory-safe-assembly
        assembly {
            success := call(gasStipend, to, selfbalance(), gas(), 0x00, gas(), 0x00)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      ERC20 OPERATIONS                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have at least `amount` approved for
    /// the current contract to manage.
    function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.
            mstore(0x60, amount) // Store the `amount` argument.
            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends all of ERC20 `token` from `from` to `to`.
    /// Reverts upon failure.
    ///
    /// The `from` account must have their entire balance approved for
    /// the current contract to manage.
    function safeTransferAllFrom(address token, address from, address to)
        internal
        returns (uint256 amount)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let m := mload(0x40) // Cache the free memory pointer.
            mstore(0x40, to) // Store the `to` argument.
            mstore(0x2c, shl(96, from)) // Store the `from` argument.
            mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
            // Read the balance, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
                )
            ) {
                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.
            amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x60, 0) // Restore the zero slot to zero.
            mstore(0x40, m) // Restore the free memory pointer.
        }
    }

    /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransfer(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    /// @dev Sends all of ERC20 `token` from the current contract to `to`.
    /// Reverts upon failure.
    function safeTransferAll(address token, address to) internal returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.
            mstore(0x20, address()) // Store the address of the current contract.
            // Read the balance, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                    staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
                )
            ) {
                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x14, to) // Store the `to` argument.
            amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.
            mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
            // Perform the transfer, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
    /// Reverts upon failure.
    function safeApprove(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
            // Perform the approval, reverting upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
                revert(0x1c, 0x04)
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
    /// If the initial attempt to approve fails, attempts to reset the approved amount to zero,
    /// then retries the approval again (some tokens, e.g. USDT, requires this).
    /// Reverts upon failure.
    function safeApproveWithRetry(address token, address to, uint256 amount) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, to) // Store the `to` argument.
            mstore(0x34, amount) // Store the `amount` argument.
            mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
            // Perform the approval, retrying upon failure.
            if iszero(
                and( // The arguments of `and` are evaluated from right to left.
                    or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                    call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                )
            ) {
                mstore(0x34, 0) // Store 0 for the `amount`.
                mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
                pop(call(gas(), token, 0, 0x10, 0x44, 0x00, 0x00)) // Reset the approval.
                mstore(0x34, amount) // Store back the original `amount`.
                // Retry the approval, reverting upon failure.
                if iszero(
                    and(
                        or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                        call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                    )
                ) {
                    mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
                    revert(0x1c, 0x04)
                }
            }
            mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
        }
    }

    /// @dev Returns the amount of ERC20 `token` owned by `account`.
    /// Returns zero if the `token` does not exist.
    function balanceOf(address token, address account) internal view returns (uint256 amount) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x14, account) // Store the `account` argument.
            mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
            amount :=
                mul(
                    mload(0x20),
                    and( // The arguments of `and` are evaluated from right to left.
                        gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                        staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
                    )
                )
        }
    }
}

// lib/solmate/src/tokens/ERC20.sol

/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 amount);

    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /*//////////////////////////////////////////////////////////////
                            METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    uint8 public immutable decimals;

    /*//////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

    mapping(address => mapping(address => uint256)) public allowance;

    /*//////////////////////////////////////////////////////////////
                            EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 internal immutable INITIAL_CHAIN_ID;

    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

    mapping(address => uint256) public nonces;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        INITIAL_CHAIN_ID = block.chainid;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
    }

    /*//////////////////////////////////////////////////////////////
                               ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 amount) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        balanceOf[msg.sender] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

        balanceOf[from] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(from, to, amount);

        return true;
    }

    /*//////////////////////////////////////////////////////////////
                             EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

        // Unchecked because the only math done is incrementing
        // the owner's nonce which cannot realistically overflow.
        unchecked {
            address recoveredAddress = ecrecover(
                keccak256(
                    abi.encodePacked(
                        "\x19\x01",
                        DOMAIN_SEPARATOR(),
                        keccak256(
                            abi.encode(
                                keccak256(
                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                ),
                                owner,
                                spender,
                                value,
                                nonces[owner]++,
                                deadline
                            )
                        )
                    )
                ),
                v,
                r,
                s
            );

            require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");

            allowance[recoveredAddress][spender] = value;
        }

        emit Approval(owner, spender, value);
    }

    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
    }

    function computeDomainSeparator() internal view virtual returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                    keccak256(bytes(name)),
                    keccak256("1"),
                    block.chainid,
                    address(this)
                )
            );
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 amount) internal virtual {
        totalSupply += amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal virtual {
        balanceOf[from] -= amount;

        // Cannot underflow because a user's balance
        // will never be larger than the total supply.
        unchecked {
            totalSupply -= amount;
        }

        emit Transfer(from, address(0), amount);
    }
}

// src/interfaces/IDepositContract.sol
// ┏━━━┓━┏┓━┏┓━━┏━━━┓━━┏━━━┓━━━━┏━━━┓━━━━━━━━━━━━━━━━━━━┏┓━━━━━┏━━━┓━━━━━━━━━┏┓━━━━━━━━━━━━━━┏┓━
// ┃┏━━┛┏┛┗┓┃┃━━┃┏━┓┃━━┃┏━┓┃━━━━┗┓┏┓┃━━━━━━━━━━━━━━━━━━┏┛┗┓━━━━┃┏━┓┃━━━━━━━━┏┛┗┓━━━━━━━━━━━━┏┛┗┓
// ┃┗━━┓┗┓┏┛┃┗━┓┗┛┏┛┃━━┃┃━┃┃━━━━━┃┃┃┃┏━━┓┏━━┓┏━━┓┏━━┓┏┓┗┓┏┛━━━━┃┃━┗┛┏━━┓┏━┓━┗┓┏┛┏━┓┏━━┓━┏━━┓┗┓┏┛
// ┃┏━━┛━┃┃━┃┏┓┃┏━┛┏┛━━┃┃━┃┃━━━━━┃┃┃┃┃┏┓┃┃┏┓┃┃┏┓┃┃━━┫┣┫━┃┃━━━━━┃┃━┏┓┃┏┓┃┃┏┓┓━┃┃━┃┏┛┗━┓┃━┃┏━┛━┃┃━
// ┃┗━━┓━┃┗┓┃┃┃┃┃┃┗━┓┏┓┃┗━┛┃━━━━┏┛┗┛┃┃┃━┫┃┗┛┃┃┗┛┃┣━━┃┃┃━┃┗┓━━━━┃┗━┛┃┃┗┛┃┃┃┃┃━┃┗┓┃┃━┃┗┛┗┓┃┗━┓━┃┗┓
// ┗━━━┛━┗━┛┗┛┗┛┗━━━┛┗┛┗━━━┛━━━━┗━━━┛┗━━┛┃┏━┛┗━━┛┗━━┛┗┛━┗━┛━━━━┗━━━┛┗━━┛┗┛┗┛━┗━┛┗┛━┗━━━┛┗━━┛━┗━┛
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┃┃━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┗┛━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

// pragma solidity 0.6.11 was the original version

// This interface is designed to be compatible with the Vyper version.
/// @notice This is the Ethereum 2.0 deposit contract interface.
/// For more information see the Phase 0 specification under https://github.com/ethereum/eth2.0-specs
interface IDepositContract {
    /// @notice A processed deposit event.
    event DepositEvent(
        bytes pubkey,
        bytes withdrawal_credentials,
        bytes amount,
        bytes signature,
        bytes index
    );

    /// @notice Submit a Phase 0 DepositData object.
    /// @param pubkey A BLS12-381 public key.
    /// @param withdrawal_credentials Commitment to a public key for withdrawals.
    /// @param signature A BLS12-381 signature.
    /// @param deposit_data_root The SHA-256 hash of the SSZ-encoded DepositData object.
    /// Used as a protection against malformed input.
    function deposit(
        bytes calldata pubkey,
        bytes calldata withdrawal_credentials,
        bytes calldata signature,
        bytes32 deposit_data_root
    ) external payable;

    /// @notice Query the current deposit root hash.
    /// @return The deposit root hash.
    function get_deposit_root() external view returns (bytes32);

    /// @notice Query the current deposit count.
    /// @return The deposit count encoded as a little endian 64-bit number.
    function get_deposit_count() external view returns (bytes memory);
}

// src/interfaces/IENSReverseRegistrar.sol

interface IENSReverseRegistrar {
  function claim(address owner) external returns (bytes32);
  function defaultResolver() external view returns (address);
  function ens() external view returns (address);
  function node(address addr) external pure returns (bytes32);
  function setName(string memory name) external returns (bytes32);
}

// lib/solady/src/auth/OwnableRoles.sol

/// @notice Simple single owner and multiroles authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
/// @dev While the ownable portion follows [EIP-173](https://eips.ethereum.org/EIPS/eip-173)
/// for compatibility, the nomenclature for the 2-step ownership handover and roles
/// may be unique to this codebase.
abstract contract OwnableRoles is Ownable {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                           EVENTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The `user`'s roles is updated to `roles`.
    /// Each bit of `roles` represents whether the role is set.
    event RolesUpdated(address indexed user, uint256 indexed roles);

    /// @dev `keccak256(bytes("RolesUpdated(address,uint256)"))`.
    uint256 private constant _ROLES_UPDATED_EVENT_SIGNATURE =
        0x715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe26;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The role slot of `user` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _ROLE_SLOT_SEED))
    ///     let roleSlot := keccak256(0x00, 0x20)
    /// ```
    /// This automatically ignores the upper bits of the `user` in case
    /// they are not clean, as well as keep the `keccak256` under 32-bytes.
    ///
    /// Note: This is equal to `_OWNER_SLOT_NOT` in for gas efficiency.
    uint256 private constant _ROLE_SLOT_SEED = 0x8b78c6d8;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     INTERNAL FUNCTIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Overwrite the roles directly without authorization guard.
    function _setRoles(address user, uint256 roles) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, user)
            // Store the new value.
            sstore(keccak256(0x0c, 0x20), roles)
            // Emit the {RolesUpdated} event.
            log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), roles)
        }
    }

    /// @dev Updates the roles directly without authorization guard.
    /// If `on` is true, each set bit of `roles` will be turned on,
    /// otherwise, each set bit of `roles` will be turned off.
    function _updateRoles(address user, uint256 roles, bool on) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, user)
            let roleSlot := keccak256(0x0c, 0x20)
            // Load the current value.
            let current := sload(roleSlot)
            // Compute the updated roles if `on` is true.
            let updated := or(current, roles)
            // Compute the updated roles if `on` is false.
            // Use `and` to compute the intersection of `current` and `roles`,
            // `xor` it with `current` to flip the bits in the intersection.
            if iszero(on) { updated := xor(current, and(current, roles)) }
            // Then, store the new value.
            sstore(roleSlot, updated)
            // Emit the {RolesUpdated} event.
            log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), updated)
        }
    }

    /// @dev Grants the roles directly without authorization guard.
    /// Each bit of `roles` represents the role to turn on.
    function _grantRoles(address user, uint256 roles) internal virtual {
        _updateRoles(user, roles, true);
    }

    /// @dev Removes the roles directly without authorization guard.
    /// Each bit of `roles` represents the role to turn off.
    function _removeRoles(address user, uint256 roles) internal virtual {
        _updateRoles(user, roles, false);
    }

    /// @dev Throws if the sender does not have any of the `roles`.
    function _checkRoles(uint256 roles) internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the role slot.
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, caller())
            // Load the stored value, and if the `and` intersection
            // of the value and `roles` is zero, revert.
            if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Throws if the sender is not the owner,
    /// and does not have any of the `roles`.
    /// Checks for ownership first, then lazily checks for roles.
    function _checkOwnerOrRoles(uint256 roles) internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner.
            // Note: `_ROLE_SLOT_SEED` is equal to `_OWNER_SLOT_NOT`.
            if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
                // Compute the role slot.
                mstore(0x0c, _ROLE_SLOT_SEED)
                mstore(0x00, caller())
                // Load the stored value, and if the `and` intersection
                // of the value and `roles` is zero, revert.
                if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
                    mstore(0x00, 0x82b42900) // `Unauthorized()`.
                    revert(0x1c, 0x04)
                }
            }
        }
    }

    /// @dev Throws if the sender does not have any of the `roles`,
    /// and is not the owner.
    /// Checks for roles first, then lazily checks for ownership.
    function _checkRolesOrOwner(uint256 roles) internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the role slot.
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, caller())
            // Load the stored value, and if the `and` intersection
            // of the value and `roles` is zero, revert.
            if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
                // If the caller is not the stored owner.
                // Note: `_ROLE_SLOT_SEED` is equal to `_OWNER_SLOT_NOT`.
                if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
                    mstore(0x00, 0x82b42900) // `Unauthorized()`.
                    revert(0x1c, 0x04)
                }
            }
        }
    }

    /// @dev Convenience function to return a `roles` bitmap from an array of `ordinals`.
    /// This is meant for frontends like Etherscan, and is therefore not fully optimized.
    /// Not recommended to be called on-chain.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _rolesFromOrdinals(uint8[] memory ordinals) internal pure returns (uint256 roles) {
        /// @solidity memory-safe-assembly
        assembly {
            for { let i := shl(5, mload(ordinals)) } i { i := sub(i, 0x20) } {
                // We don't need to mask the values of `ordinals`, as Solidity
                // cleans dirty upper bits when storing variables into memory.
                roles := or(shl(mload(add(ordinals, i)), 1), roles)
            }
        }
    }

    /// @dev Convenience function to return an array of `ordinals` from the `roles` bitmap.
    /// This is meant for frontends like Etherscan, and is therefore not fully optimized.
    /// Not recommended to be called on-chain.
    /// Made internal to conserve bytecode. Wrap it in a public function if needed.
    function _ordinalsFromRoles(uint256 roles) internal pure returns (uint8[] memory ordinals) {
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the pointer to the free memory.
            ordinals := mload(0x40)
            let ptr := add(ordinals, 0x20)
            let o := 0
            // The absence of lookup tables, De Bruijn, etc., here is intentional for
            // smaller bytecode, as this function is not meant to be called on-chain.
            for { let t := roles } 1 {} {
                mstore(ptr, o)
                // `shr` 5 is equivalent to multiplying by 0x20.
                // Push back into the ordinals array if the bit is set.
                ptr := add(ptr, shl(5, and(t, 1)))
                o := add(o, 1)
                t := shr(o, roles)
                if iszero(t) { break }
            }
            // Store the length of `ordinals`.
            mstore(ordinals, shr(5, sub(ptr, add(ordinals, 0x20))))
            // Allocate the memory.
            mstore(0x40, ptr)
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  PUBLIC UPDATE FUNCTIONS                   */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Allows the owner to grant `user` `roles`.
    /// If the `user` already has a role, then it will be an no-op for the role.
    function grantRoles(address user, uint256 roles) public payable virtual onlyOwner {
        _grantRoles(user, roles);
    }

    /// @dev Allows the owner to remove `user` `roles`.
    /// If the `user` does not have a role, then it will be an no-op for the role.
    function revokeRoles(address user, uint256 roles) public payable virtual onlyOwner {
        _removeRoles(user, roles);
    }

    /// @dev Allow the caller to remove their own roles.
    /// If the caller does not have a role, then it will be an no-op for the role.
    function renounceRoles(uint256 roles) public payable virtual {
        _removeRoles(msg.sender, roles);
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                   PUBLIC READ FUNCTIONS                    */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the roles of `user`.
    function rolesOf(address user) public view virtual returns (uint256 roles) {
        /// @solidity memory-safe-assembly
        assembly {
            // Compute the role slot.
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, user)
            // Load the stored value.
            roles := sload(keccak256(0x0c, 0x20))
        }
    }

    /// @dev Returns whether `user` has any of `roles`.
    function hasAnyRole(address user, uint256 roles) public view virtual returns (bool) {
        return rolesOf(user) & roles != 0;
    }

    /// @dev Returns whether `user` has all of `roles`.
    function hasAllRoles(address user, uint256 roles) public view virtual returns (bool) {
        return rolesOf(user) & roles == roles;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         MODIFIERS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Marks a function as only callable by an account with `roles`.
    modifier onlyRoles(uint256 roles) virtual {
        _checkRoles(roles);
        _;
    }

    /// @dev Marks a function as only callable by the owner or by an account
    /// with `roles`. Checks for ownership first, then lazily checks for roles.
    modifier onlyOwnerOrRoles(uint256 roles) virtual {
        _checkOwnerOrRoles(roles);
        _;
    }

    /// @dev Marks a function as only callable by an account with `roles`
    /// or the owner. Checks for roles first, then lazily checks for ownership.
    modifier onlyRolesOrOwner(uint256 roles) virtual {
        _checkRolesOrOwner(roles);
        _;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       ROLE CONSTANTS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // IYKYK

    uint256 internal constant _ROLE_0 = 1 << 0;
    uint256 internal constant _ROLE_1 = 1 << 1;
    uint256 internal constant _ROLE_2 = 1 << 2;
    uint256 internal constant _ROLE_3 = 1 << 3;
    uint256 internal constant _ROLE_4 = 1 << 4;
    uint256 internal constant _ROLE_5 = 1 << 5;
    uint256 internal constant _ROLE_6 = 1 << 6;
    uint256 internal constant _ROLE_7 = 1 << 7;
    uint256 internal constant _ROLE_8 = 1 << 8;
    uint256 internal constant _ROLE_9 = 1 << 9;
    uint256 internal constant _ROLE_10 = 1 << 10;
    uint256 internal constant _ROLE_11 = 1 << 11;
    uint256 internal constant _ROLE_12 = 1 << 12;
    uint256 internal constant _ROLE_13 = 1 << 13;
    uint256 internal constant _ROLE_14 = 1 << 14;
    uint256 internal constant _ROLE_15 = 1 << 15;
    uint256 internal constant _ROLE_16 = 1 << 16;
    uint256 internal constant _ROLE_17 = 1 << 17;
    uint256 internal constant _ROLE_18 = 1 << 18;
    uint256 internal constant _ROLE_19 = 1 << 19;
    uint256 internal constant _ROLE_20 = 1 << 20;
    uint256 internal constant _ROLE_21 = 1 << 21;
    uint256 internal constant _ROLE_22 = 1 << 22;
    uint256 internal constant _ROLE_23 = 1 << 23;
    uint256 internal constant _ROLE_24 = 1 << 24;
    uint256 internal constant _ROLE_25 = 1 << 25;
    uint256 internal constant _ROLE_26 = 1 << 26;
    uint256 internal constant _ROLE_27 = 1 << 27;
    uint256 internal constant _ROLE_28 = 1 << 28;
    uint256 internal constant _ROLE_29 = 1 << 29;
    uint256 internal constant _ROLE_30 = 1 << 30;
    uint256 internal constant _ROLE_31 = 1 << 31;
    uint256 internal constant _ROLE_32 = 1 << 32;
    uint256 internal constant _ROLE_33 = 1 << 33;
    uint256 internal constant _ROLE_34 = 1 << 34;
    uint256 internal constant _ROLE_35 = 1 << 35;
    uint256 internal constant _ROLE_36 = 1 << 36;
    uint256 internal constant _ROLE_37 = 1 << 37;
    uint256 internal constant _ROLE_38 = 1 << 38;
    uint256 internal constant _ROLE_39 = 1 << 39;
    uint256 internal constant _ROLE_40 = 1 << 40;
    uint256 internal constant _ROLE_41 = 1 << 41;
    uint256 internal constant _ROLE_42 = 1 << 42;
    uint256 internal constant _ROLE_43 = 1 << 43;
    uint256 internal constant _ROLE_44 = 1 << 44;
    uint256 internal constant _ROLE_45 = 1 << 45;
    uint256 internal constant _ROLE_46 = 1 << 46;
    uint256 internal constant _ROLE_47 = 1 << 47;
    uint256 internal constant _ROLE_48 = 1 << 48;
    uint256 internal constant _ROLE_49 = 1 << 49;
    uint256 internal constant _ROLE_50 = 1 << 50;
    uint256 internal constant _ROLE_51 = 1 << 51;
    uint256 internal constant _ROLE_52 = 1 << 52;
    uint256 internal constant _ROLE_53 = 1 << 53;
    uint256 internal constant _ROLE_54 = 1 << 54;
    uint256 internal constant _ROLE_55 = 1 << 55;
    uint256 internal constant _ROLE_56 = 1 << 56;
    uint256 internal constant _ROLE_57 = 1 << 57;
    uint256 internal constant _ROLE_58 = 1 << 58;
    uint256 internal constant _ROLE_59 = 1 << 59;
    uint256 internal constant _ROLE_60 = 1 << 60;
    uint256 internal constant _ROLE_61 = 1 << 61;
    uint256 internal constant _ROLE_62 = 1 << 62;
    uint256 internal constant _ROLE_63 = 1 << 63;
    uint256 internal constant _ROLE_64 = 1 << 64;
    uint256 internal constant _ROLE_65 = 1 << 65;
    uint256 internal constant _ROLE_66 = 1 << 66;
    uint256 internal constant _ROLE_67 = 1 << 67;
    uint256 internal constant _ROLE_68 = 1 << 68;
    uint256 internal constant _ROLE_69 = 1 << 69;
    uint256 internal constant _ROLE_70 = 1 << 70;
    uint256 internal constant _ROLE_71 = 1 << 71;
    uint256 internal constant _ROLE_72 = 1 << 72;
    uint256 internal constant _ROLE_73 = 1 << 73;
    uint256 internal constant _ROLE_74 = 1 << 74;
    uint256 internal constant _ROLE_75 = 1 << 75;
    uint256 internal constant _ROLE_76 = 1 << 76;
    uint256 internal constant _ROLE_77 = 1 << 77;
    uint256 internal constant _ROLE_78 = 1 << 78;
    uint256 internal constant _ROLE_79 = 1 << 79;
    uint256 internal constant _ROLE_80 = 1 << 80;
    uint256 internal constant _ROLE_81 = 1 << 81;
    uint256 internal constant _ROLE_82 = 1 << 82;
    uint256 internal constant _ROLE_83 = 1 << 83;
    uint256 internal constant _ROLE_84 = 1 << 84;
    uint256 internal constant _ROLE_85 = 1 << 85;
    uint256 internal constant _ROLE_86 = 1 << 86;
    uint256 internal constant _ROLE_87 = 1 << 87;
    uint256 internal constant _ROLE_88 = 1 << 88;
    uint256 internal constant _ROLE_89 = 1 << 89;
    uint256 internal constant _ROLE_90 = 1 << 90;
    uint256 internal constant _ROLE_91 = 1 << 91;
    uint256 internal constant _ROLE_92 = 1 << 92;
    uint256 internal constant _ROLE_93 = 1 << 93;
    uint256 internal constant _ROLE_94 = 1 << 94;
    uint256 internal constant _ROLE_95 = 1 << 95;
    uint256 internal constant _ROLE_96 = 1 << 96;
    uint256 internal constant _ROLE_97 = 1 << 97;
    uint256 internal constant _ROLE_98 = 1 << 98;
    uint256 internal constant _ROLE_99 = 1 << 99;
    uint256 internal constant _ROLE_100 = 1 << 100;
    uint256 internal constant _ROLE_101 = 1 << 101;
    uint256 internal constant _ROLE_102 = 1 << 102;
    uint256 internal constant _ROLE_103 = 1 << 103;
    uint256 internal constant _ROLE_104 = 1 << 104;
    uint256 internal constant _ROLE_105 = 1 << 105;
    uint256 internal constant _ROLE_106 = 1 << 106;
    uint256 internal constant _ROLE_107 = 1 << 107;
    uint256 internal constant _ROLE_108 = 1 << 108;
    uint256 internal constant _ROLE_109 = 1 << 109;
    uint256 internal constant _ROLE_110 = 1 << 110;
    uint256 internal constant _ROLE_111 = 1 << 111;
    uint256 internal constant _ROLE_112 = 1 << 112;
    uint256 internal constant _ROLE_113 = 1 << 113;
    uint256 internal constant _ROLE_114 = 1 << 114;
    uint256 internal constant _ROLE_115 = 1 << 115;
    uint256 internal constant _ROLE_116 = 1 << 116;
    uint256 internal constant _ROLE_117 = 1 << 117;
    uint256 internal constant _ROLE_118 = 1 << 118;
    uint256 internal constant _ROLE_119 = 1 << 119;
    uint256 internal constant _ROLE_120 = 1 << 120;
    uint256 internal constant _ROLE_121 = 1 << 121;
    uint256 internal constant _ROLE_122 = 1 << 122;
    uint256 internal constant _ROLE_123 = 1 << 123;
    uint256 internal constant _ROLE_124 = 1 << 124;
    uint256 internal constant _ROLE_125 = 1 << 125;
    uint256 internal constant _ROLE_126 = 1 << 126;
    uint256 internal constant _ROLE_127 = 1 << 127;
    uint256 internal constant _ROLE_128 = 1 << 128;
    uint256 internal constant _ROLE_129 = 1 << 129;
    uint256 internal constant _ROLE_130 = 1 << 130;
    uint256 internal constant _ROLE_131 = 1 << 131;
    uint256 internal constant _ROLE_132 = 1 << 132;
    uint256 internal constant _ROLE_133 = 1 << 133;
    uint256 internal constant _ROLE_134 = 1 << 134;
    uint256 internal constant _ROLE_135 = 1 << 135;
    uint256 internal constant _ROLE_136 = 1 << 136;
    uint256 internal constant _ROLE_137 = 1 << 137;
    uint256 internal constant _ROLE_138 = 1 << 138;
    uint256 internal constant _ROLE_139 = 1 << 139;
    uint256 internal constant _ROLE_140 = 1 << 140;
    uint256 internal constant _ROLE_141 = 1 << 141;
    uint256 internal constant _ROLE_142 = 1 << 142;
    uint256 internal constant _ROLE_143 = 1 << 143;
    uint256 internal constant _ROLE_144 = 1 << 144;
    uint256 internal constant _ROLE_145 = 1 << 145;
    uint256 internal constant _ROLE_146 = 1 << 146;
    uint256 internal constant _ROLE_147 = 1 << 147;
    uint256 internal constant _ROLE_148 = 1 << 148;
    uint256 internal constant _ROLE_149 = 1 << 149;
    uint256 internal constant _ROLE_150 = 1 << 150;
    uint256 internal constant _ROLE_151 = 1 << 151;
    uint256 internal constant _ROLE_152 = 1 << 152;
    uint256 internal constant _ROLE_153 = 1 << 153;
    uint256 internal constant _ROLE_154 = 1 << 154;
    uint256 internal constant _ROLE_155 = 1 << 155;
    uint256 internal constant _ROLE_156 = 1 << 156;
    uint256 internal constant _ROLE_157 = 1 << 157;
    uint256 internal constant _ROLE_158 = 1 << 158;
    uint256 internal constant _ROLE_159 = 1 << 159;
    uint256 internal constant _ROLE_160 = 1 << 160;
    uint256 internal constant _ROLE_161 = 1 << 161;
    uint256 internal constant _ROLE_162 = 1 << 162;
    uint256 internal constant _ROLE_163 = 1 << 163;
    uint256 internal constant _ROLE_164 = 1 << 164;
    uint256 internal constant _ROLE_165 = 1 << 165;
    uint256 internal constant _ROLE_166 = 1 << 166;
    uint256 internal constant _ROLE_167 = 1 << 167;
    uint256 internal constant _ROLE_168 = 1 << 168;
    uint256 internal constant _ROLE_169 = 1 << 169;
    uint256 internal constant _ROLE_170 = 1 << 170;
    uint256 internal constant _ROLE_171 = 1 << 171;
    uint256 internal constant _ROLE_172 = 1 << 172;
    uint256 internal constant _ROLE_173 = 1 << 173;
    uint256 internal constant _ROLE_174 = 1 << 174;
    uint256 internal constant _ROLE_175 = 1 << 175;
    uint256 internal constant _ROLE_176 = 1 << 176;
    uint256 internal constant _ROLE_177 = 1 << 177;
    uint256 internal constant _ROLE_178 = 1 << 178;
    uint256 internal constant _ROLE_179 = 1 << 179;
    uint256 internal constant _ROLE_180 = 1 << 180;
    uint256 internal constant _ROLE_181 = 1 << 181;
    uint256 internal constant _ROLE_182 = 1 << 182;
    uint256 internal constant _ROLE_183 = 1 << 183;
    uint256 internal constant _ROLE_184 = 1 << 184;
    uint256 internal constant _ROLE_185 = 1 << 185;
    uint256 internal constant _ROLE_186 = 1 << 186;
    uint256 internal constant _ROLE_187 = 1 << 187;
    uint256 internal constant _ROLE_188 = 1 << 188;
    uint256 internal constant _ROLE_189 = 1 << 189;
    uint256 internal constant _ROLE_190 = 1 << 190;
    uint256 internal constant _ROLE_191 = 1 << 191;
    uint256 internal constant _ROLE_192 = 1 << 192;
    uint256 internal constant _ROLE_193 = 1 << 193;
    uint256 internal constant _ROLE_194 = 1 << 194;
    uint256 internal constant _ROLE_195 = 1 << 195;
    uint256 internal constant _ROLE_196 = 1 << 196;
    uint256 internal constant _ROLE_197 = 1 << 197;
    uint256 internal constant _ROLE_198 = 1 << 198;
    uint256 internal constant _ROLE_199 = 1 << 199;
    uint256 internal constant _ROLE_200 = 1 << 200;
    uint256 internal constant _ROLE_201 = 1 << 201;
    uint256 internal constant _ROLE_202 = 1 << 202;
    uint256 internal constant _ROLE_203 = 1 << 203;
    uint256 internal constant _ROLE_204 = 1 << 204;
    uint256 internal constant _ROLE_205 = 1 << 205;
    uint256 internal constant _ROLE_206 = 1 << 206;
    uint256 internal constant _ROLE_207 = 1 << 207;
    uint256 internal constant _ROLE_208 = 1 << 208;
    uint256 internal constant _ROLE_209 = 1 << 209;
    uint256 internal constant _ROLE_210 = 1 << 210;
    uint256 internal constant _ROLE_211 = 1 << 211;
    uint256 internal constant _ROLE_212 = 1 << 212;
    uint256 internal constant _ROLE_213 = 1 << 213;
    uint256 internal constant _ROLE_214 = 1 << 214;
    uint256 internal constant _ROLE_215 = 1 << 215;
    uint256 internal constant _ROLE_216 = 1 << 216;
    uint256 internal constant _ROLE_217 = 1 << 217;
    uint256 internal constant _ROLE_218 = 1 << 218;
    uint256 internal constant _ROLE_219 = 1 << 219;
    uint256 internal constant _ROLE_220 = 1 << 220;
    uint256 internal constant _ROLE_221 = 1 << 221;
    uint256 internal constant _ROLE_222 = 1 << 222;
    uint256 internal constant _ROLE_223 = 1 << 223;
    uint256 internal constant _ROLE_224 = 1 << 224;
    uint256 internal constant _ROLE_225 = 1 << 225;
    uint256 internal constant _ROLE_226 = 1 << 226;
    uint256 internal constant _ROLE_227 = 1 << 227;
    uint256 internal constant _ROLE_228 = 1 << 228;
    uint256 internal constant _ROLE_229 = 1 << 229;
    uint256 internal constant _ROLE_230 = 1 << 230;
    uint256 internal constant _ROLE_231 = 1 << 231;
    uint256 internal constant _ROLE_232 = 1 << 232;
    uint256 internal constant _ROLE_233 = 1 << 233;
    uint256 internal constant _ROLE_234 = 1 << 234;
    uint256 internal constant _ROLE_235 = 1 << 235;
    uint256 internal constant _ROLE_236 = 1 << 236;
    uint256 internal constant _ROLE_237 = 1 << 237;
    uint256 internal constant _ROLE_238 = 1 << 238;
    uint256 internal constant _ROLE_239 = 1 << 239;
    uint256 internal constant _ROLE_240 = 1 << 240;
    uint256 internal constant _ROLE_241 = 1 << 241;
    uint256 internal constant _ROLE_242 = 1 << 242;
    uint256 internal constant _ROLE_243 = 1 << 243;
    uint256 internal constant _ROLE_244 = 1 << 244;
    uint256 internal constant _ROLE_245 = 1 << 245;
    uint256 internal constant _ROLE_246 = 1 << 246;
    uint256 internal constant _ROLE_247 = 1 << 247;
    uint256 internal constant _ROLE_248 = 1 << 248;
    uint256 internal constant _ROLE_249 = 1 << 249;
    uint256 internal constant _ROLE_250 = 1 << 250;
    uint256 internal constant _ROLE_251 = 1 << 251;
    uint256 internal constant _ROLE_252 = 1 << 252;
    uint256 internal constant _ROLE_253 = 1 << 253;
    uint256 internal constant _ROLE_254 = 1 << 254;
    uint256 internal constant _ROLE_255 = 1 << 255;
}

// src/ovm/ObolValidatorManager.sol

/// @title ObolValidatorManager
/// @author Obol
/// @notice A maximally-composable contract that distributes payments
/// based on threshold to it's recipients.
/// @dev Only ETH can be distributed for a given deployment. There is a
/// recovery method for tokens sent by accident.
contract ObolValidatorManager is OwnableRoles {
  /// -----------------------------------------------------------------------
  /// libraries
  /// -----------------------------------------------------------------------

  using SafeTransferLib for address;

  /// -----------------------------------------------------------------------
  /// errors
  /// -----------------------------------------------------------------------

  // Invalid request params, e.g. empty input
  error InvalidRequest_Params();

  // Failed to call system contract get_fee()
  error InvalidRequest_SystemGetFee();

  // Insufficient fee provided in the call's value to conclude the request
  error InvalidRequest_NotEnoughFee();

  // Failed to call system contract add_consolidation_request()
  error InvalidConsolidation_Failed();

  // Failed to call system contract add_withdrawal_request()
  error InvalidWithdrawal_Failed();

  /// Invalid distribution
  error InvalidDistribution_TooLarge();

  /// -----------------------------------------------------------------------
  /// events
  /// -----------------------------------------------------------------------

  /// Emitted after principal recipient is changed
  /// @param newPrincipalRecipient New principal recipient address
  /// @param oldPrincipalRecipient Old principal recipient address
  event NewPrincipalRecipient(address indexed newPrincipalRecipient, address indexed oldPrincipalRecipient);

  /// Emitted after funds are distributed to recipients
  /// @param principalPayout Amount of principal paid out
  /// @param rewardPayout Amount of reward paid out
  /// @param pullOrPush Flag indicating PULL or PUSH flow
  event DistributeFunds(uint256 principalPayout, uint256 rewardPayout, uint256 pullOrPush);

  /// Emitted after tokens are recovered to a recipient
  /// @param nonOVMToken Recovered token (cannot be ETH)
  /// @param recipient Address receiving recovered token
  /// @param amount Amount of recovered token
  event RecoverNonOVMFunds(address indexed nonOVMToken, address indexed recipient, uint256 amount);

  /// Emitted after funds withdrawn using pull flow
  /// @param account Account withdrawing funds for
  /// @param amount Amount withdrawn
  event Withdrawal(address indexed account, uint256 amount);

  /// Emitted when a Pectra consolidation request is done
  /// @param requester Address of the requester
  /// @param source Source validator public key
  /// @param target Target validator public key
  event ConsolidationRequested(address indexed requester, bytes indexed source, bytes indexed target);

  /// Emitted when a Pectra withdrawal request is done
  /// @param requester Address of the requester
  /// @param pubKey Validator public key
  /// @param amount Withdrawal amount
  event WithdrawalRequested(address indexed requester, bytes indexed pubKey, uint256 amount);

  /// -----------------------------------------------------------------------
  /// storage
  /// -----------------------------------------------------------------------

  /// -----------------------------------------------------------------------
  /// storage - constants
  /// -----------------------------------------------------------------------

  uint256 public constant WITHDRAWAL_ROLE = 0x01;
  uint256 public constant CONSOLIDATION_ROLE = 0x02;
  uint256 public constant SET_PRINCIPAL_ROLE = 0x04;
  uint256 public constant RECOVER_FUNDS_ROLE = 0x08;

  uint256 internal constant PUSH = 0;
  uint256 internal constant PULL = 1;

  uint256 internal constant PUBLIC_KEY_LENGTH = 48;

  /// -----------------------------------------------------------------------
  /// storage - immutable
  /// -----------------------------------------------------------------------

  address public immutable consolidationSystemContract;
  address public immutable withdrawalSystemContract;
  address public immutable depositSystemContract;
  address public immutable rewardRecipient;
  uint64 public immutable principalThreshold;

  /// -----------------------------------------------------------------------
  /// storage - mutables
  /// -----------------------------------------------------------------------

  /// Address to receive principal funds
  address public principalRecipient;

  /// Amount of principal stake (wei) done via deposit() calls
  uint256 public amountOfPrincipalStake;

  /// Amount of active balance set aside for pulls
  /// @dev ERC20s with very large decimals may overflow & cause issues
  uint128 public fundsPendingWithdrawal;

  /// Mapping to account balances for pulling
  mapping(address => uint256) internal pullBalances;

  /// -----------------------------------------------------------------------
  /// constructor
  /// -----------------------------------------------------------------------

  constructor(
    address _consolidationSystemContract,
    address _withdrawalSystemContract,
    address _depositSystemContract,
    address _owner,
    address _principalRecipient,
    address _rewardRecipient,
    uint64 _principalThreshold
  ) {
    consolidationSystemContract = _consolidationSystemContract;
    withdrawalSystemContract = _withdrawalSystemContract;
    depositSystemContract = _depositSystemContract;
    principalRecipient = _principalRecipient;
    rewardRecipient = _rewardRecipient;
    principalThreshold = _principalThreshold;

    _initializeOwner(_owner);
  }

  /// -----------------------------------------------------------------------
  /// functions
  /// -----------------------------------------------------------------------

  /// -----------------------------------------------------------------------
  /// functions - public & external
  /// -----------------------------------------------------------------------

  /// @dev Fallback function to receive ETH
  ///      Because we do not use Clone, we must implement this explicitly
  receive() external payable {}

  /// @notice Submit a Phase 0 DepositData object.
  /// @param pubkey A BLS12-381 public key.
  /// @param withdrawal_credentials Commitment to a public key for withdrawals.
  /// @param signature A BLS12-381 signature.
  /// @param deposit_data_root The SHA-256 hash of the SSZ-encoded DepositData object.
  /// Used as a protection against malformed input.
  /// @dev This function is a proxy to the deposit() function on the depositSystemContract.
  ///      The deposited amount is accounted for in the amountOfPrincipalStake, which is used
  ///      to determine the principalRecipient's share of the funds to be distributed.
  ///      Any deposits made directly to the depositSystemContract will not be accounted for
  ///      and will be sent to the rewardRecipient address.
  function deposit(
    bytes calldata pubkey,
    bytes calldata withdrawal_credentials,
    bytes calldata signature,
    bytes32 deposit_data_root
  ) external payable {
    amountOfPrincipalStake += msg.value;
    IDepositContract(depositSystemContract).deposit{value: msg.value}(
      pubkey,
      withdrawal_credentials,
      signature,
      deposit_data_root
    );
  }

  /// @notice Set the principal recipient address
  /// @param newPrincipalRecipient New address to receive principal funds
  function setPrincipalRecipient(address newPrincipalRecipient) external onlyOwnerOrRoles(SET_PRINCIPAL_ROLE) {
    if (newPrincipalRecipient == address(0)) {
      revert InvalidRequest_Params();
    }

    address oldPrincipalRecipient = principalRecipient;
    principalRecipient = newPrincipalRecipient;

    emit NewPrincipalRecipient(newPrincipalRecipient, oldPrincipalRecipient);
  }

  /// Distributes target token inside the contract to recipients
  /// @dev pushes funds to recipients
  function distributeFunds() external {
    _distributeFunds(PUSH);
  }

  /// Distributes target token inside the contract to recipients
  /// @dev backup recovery if any recipient tries to brick the OVM for
  /// remaining recipients
  function distributeFundsPull() external {
    _distributeFunds(PULL);
  }

  /// Request validators consolidation with the EIP7251 system contract
  /// @dev all source validators will be consolidated into the target validator
  ///      the caller must compute the fee before calling and send a sufficient msg.value amount
  ///      excess amount will be refunded
  /// @param sourcePubKeys validator public keys to be consolidated
  /// @param targetPubKey target validator public key
  function requestConsolidation(
    bytes[] calldata sourcePubKeys,
    bytes calldata targetPubKey
  ) external payable onlyOwnerOrRoles(CONSOLIDATION_ROLE) {
    if (sourcePubKeys.length == 0 || sourcePubKeys.length > 63 || targetPubKey.length != PUBLIC_KEY_LENGTH)
      revert InvalidRequest_Params();

    uint256 remainingFee = msg.value;
    uint256 len = sourcePubKeys.length;

    for (uint256 i; i < len; ) {
      uint256 _currentFee = _computeSystemContractFee(consolidationSystemContract);
      if (_currentFee > remainingFee) revert InvalidRequest_NotEnoughFee();

      remainingFee -= _currentFee;
      _requestConsolidation(sourcePubKeys[i], targetPubKey, _currentFee);

      unchecked {
        ++i;
      }
    }

    // Future optimization idea: do not send if gas cost exceeds the value.
    if (remainingFee > 0) payable(msg.sender).transfer(remainingFee);
  }

  /// Request partial/full withdrawal from the EIP7002 system contract
  /// @dev the caller must compute the fee before calling and send a sufficient msg.value amount
  ///      excess amount will be refunded
  ///      withdrawals that leave a validator with (0..32) ether,
  //       will only withdraw an amount that leaves the validator at 32 ether
  /// @param pubKeys validator public keys
  /// @param amounts withdrawal amounts in gwei
  ///                any amount below principalThreshold will be distributed as reward
  ///                any amount >= principalThreshold will be distributed as principal
  function requestWithdrawal(
    bytes[] calldata pubKeys,
    uint64[] calldata amounts
  ) external payable onlyOwnerOrRoles(WITHDRAWAL_ROLE) {
    if (pubKeys.length != amounts.length) revert InvalidRequest_Params();

    uint256 remainingFee = msg.value;
    uint256 len = pubKeys.length;

    for (uint256 i; i < len; ) {
      uint256 _currentFee = _computeSystemContractFee(withdrawalSystemContract);
      if (_currentFee > remainingFee) revert InvalidRequest_NotEnoughFee();

      remainingFee -= _currentFee;
      _requestWithdrawal(pubKeys[i], amounts[i], _currentFee);

      unchecked {
        ++i;
      }
    }

    // Future optimization idea: do not send if gas cost exceeds the value.
    if (remainingFee > 0) payable(msg.sender).transfer(remainingFee);
  }

  /// Recover non-OVM tokens to a recipient
  /// @param nonOVMToken Token to recover (cannot be OVM token)
  /// @param recipient Address to receive recovered token
  function recoverFunds(address nonOVMToken, address recipient) external onlyOwnerOrRoles(RECOVER_FUNDS_ROLE) {
    uint256 amount = ERC20(nonOVMToken).balanceOf(address(this));
    nonOVMToken.safeTransfer(recipient, amount);

    emit RecoverNonOVMFunds(nonOVMToken, recipient, amount);
  }

  /// Withdraw token balance for an account
  /// @param account Address to withdraw on behalf of
  function withdraw(address account) external {
    uint256 amount = pullBalances[account];
    unchecked {
      // shouldn't underflow; fundsPendingWithdrawal = sum(pullBalances)
      fundsPendingWithdrawal -= uint128(amount);
    }
    pullBalances[account] = 0;
    account.safeTransferETH(amount);

    emit Withdrawal(account, amount);
  }

  /// -----------------------------------------------------------------------
  /// functions - view & pure
  /// -----------------------------------------------------------------------

  /// Returns the balance for the account `account`
  /// @param account Account to return balance for
  /// @return Account's withdrawable ether balance
  function getPullBalance(address account) external view returns (uint256) {
    return pullBalances[account];
  }

  /// -----------------------------------------------------------------------
  /// functions - private & internal
  /// -----------------------------------------------------------------------

  /// Compute system contract's fee
  /// @param systemContractAddress Address of the consolidation system contract
  /// @return The computed fee
  function _computeSystemContractFee(address systemContractAddress) internal view returns (uint256) {
    (bool ok, bytes memory result) = systemContractAddress.staticcall("");
    if (!ok) revert InvalidRequest_SystemGetFee();

    return uint256(bytes32(result));
  }

  /// Execute a single consolidation request
  /// @param source Source validator public key
  /// @param target Target validator public key
  /// @param fee Fee for the consolidation request
  function _requestConsolidation(bytes calldata source, bytes calldata target, uint256 fee) private {
    if (source.length != PUBLIC_KEY_LENGTH || target.length != PUBLIC_KEY_LENGTH) revert InvalidRequest_Params();

    // Input data has the following layout:
    //
    //  +--------+--------+
    //  | source | target |
    //  +--------+--------+
    //      48       48

    (bool ok, ) = consolidationSystemContract.call{value: fee}(bytes.concat(source, target));
    if (!ok) revert InvalidConsolidation_Failed();

    emit ConsolidationRequested(msg.sender, source, target);
  }

  /// Executes single withdrawal request
  function _requestWithdrawal(bytes memory pubkey, uint64 amount, uint256 fee) private {
    if (pubkey.length != PUBLIC_KEY_LENGTH) revert InvalidRequest_Params();

    // Input data has the following layout:
    //
    //  +--------+--------+
    //  | pubkey | amount |
    //  +--------+--------+
    //      48       8
    (bool ret, ) = withdrawalSystemContract.call{value: fee}(abi.encodePacked(pubkey, amount));
    if (!ret) revert InvalidWithdrawal_Failed();

    emit WithdrawalRequested(msg.sender, pubkey, amount);
  }

  /// Distributes target token inside the contract to next-in-line recipients
  /// @dev can PUSH or PULL funds to recipients
  function _distributeFunds(uint256 pullOrPush) internal {
    /// checks

    /// effects

    // load storage into memory
    uint256 currentbalance = address(this).balance;
    uint256 _memoryFundsPendingWithdrawal = uint256(fundsPendingWithdrawal);
    uint256 _fundsToBeDistributed = currentbalance - _memoryFundsPendingWithdrawal;
    uint256 principalThresholdWei = uint256(principalThreshold) * 1e9;

    // determine which recipeint is getting paid based on funds to be distributed
    uint256 _principalPayout = 0;
    uint256 _rewardPayout = 0;

    unchecked {
      if (_fundsToBeDistributed >= principalThresholdWei && amountOfPrincipalStake > 0) {
        if (_fundsToBeDistributed > amountOfPrincipalStake) {
          // this means there is reward part of the funds to be distributed
          _principalPayout = amountOfPrincipalStake;
          // shouldn't underflow
          _rewardPayout = _fundsToBeDistributed - amountOfPrincipalStake;
        } else {
          // this means there is no reward part of the funds to be distributed
          _principalPayout = _fundsToBeDistributed;
        }
      } else {
        _rewardPayout = _fundsToBeDistributed;
      }
    }

    {
      if (_fundsToBeDistributed > type(uint128).max) revert InvalidDistribution_TooLarge();
      // Write to storage
      // the principal value
      // it cannot overflow because _principalPayout < _fundsToBeDistributed
      if (_principalPayout > 0) amountOfPrincipalStake -= uint128(_principalPayout);
    }

    /// interactions

    // pay outs
    // earlier tranche recipients may try to re-enter but will cause fn to
    // revert
    // when later external calls fail (bc balance is emptied early)

    // pay out principal
    _payout(principalRecipient, _principalPayout, pullOrPush);
    // pay out reward
    _payout(rewardRecipient, _rewardPayout, pullOrPush);

    if (pullOrPush == PULL) {
      if (_principalPayout > 0 || _rewardPayout > 0) {
        // Write to storage
        fundsPendingWithdrawal = uint128(_memoryFundsPendingWithdrawal + _principalPayout + _rewardPayout);
      }
    }

    emit DistributeFunds(_principalPayout, _rewardPayout, pullOrPush);
  }

  function _payout(address recipient, uint256 payoutAmount, uint256 pullOrPush) internal {
    if (payoutAmount > 0) {
      if (pullOrPush == PULL) {
        // Write to Storage
        pullBalances[recipient] += payoutAmount;
      } else if (pullOrPush == PUSH) {
        recipient.safeTransferETH(payoutAmount);
      } else {
        revert InvalidRequest_Params();
      }
    }
  }
}

[{"inputs":[{"internalType":"address","name":"_consolidationSystemContract","type":"address"},{"internalType":"address","name":"_withdrawalSystemContract","type":"address"},{"internalType":"address","name":"_depositSystemContract","type":"address"},{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_principalRecipient","type":"address"},{"internalType":"address","name":"_rewardRecipient","type":"address"},{"internalType":"uint64","name":"_principalThreshold","type":"uint64"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidConsolidation_Failed","type":"error"},{"inputs":[],"name":"InvalidDistribution_TooLarge","type":"error"},{"inputs":[],"name":"InvalidRequest_NotEnoughFee","type":"error"},{"inputs":[],"name":"InvalidRequest_Params","type":"error"},{"inputs":[],"name":"InvalidRequest_SystemGetFee","type":"error"},{"inputs":[],"name":"InvalidWithdrawal_Failed","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[],"name":"Unauthorized","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"requester","type":"address"},{"indexed":true,"internalType":"bytes","name":"source","type":"bytes"},{"indexed":true,"internalType":"bytes","name":"target","type":"bytes"}],"name":"ConsolidationRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"principalPayout","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"rewardPayout","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"pullOrPush","type":"uint256"}],"name":"DistributeFunds","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newPrincipalRecipient","type":"address"},{"indexed":true,"internalType":"address","name":"oldPrincipalRecipient","type":"address"}],"name":"NewPrincipalRecipient","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverCanceled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pendingOwner","type":"address"}],"name":"OwnershipHandoverRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"nonOVMToken","type":"address"},{"indexed":true,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RecoverNonOVMFunds","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"roles","type":"uint256"}],"name":"RolesUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawal","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"requester","type":"address"},{"indexed":true,"internalType":"bytes","name":"pubKey","type":"bytes"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawalRequested","type":"event"},{"inputs":[],"name":"CONSOLIDATION_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"RECOVER_FUNDS_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SET_PRINCIPAL_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WITHDRAWAL_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"amountOfPrincipalStake","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"completeOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"consolidationSystemContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"pubkey","type":"bytes"},{"internalType":"bytes","name":"withdrawal_credentials","type":"bytes"},{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"bytes32","name":"deposit_data_root","type":"bytes32"}],"name":"deposit","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"depositSystemContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distributeFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"distributeFundsPull","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"fundsPendingWithdrawal","outputs":[{"internalType":"uint128","name":"","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getPullBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"grantRoles","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"hasAllRoles","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"hasAnyRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pendingOwner","type":"address"}],"name":"ownershipHandoverExpiresAt","outputs":[{"internalType":"uint256","name":"result","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"principalRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"principalThreshold","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"nonOVMToken","type":"address"},{"internalType":"address","name":"recipient","type":"address"}],"name":"recoverFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"renounceRoles","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"sourcePubKeys","type":"bytes[]"},{"internalType":"bytes","name":"targetPubKey","type":"bytes"}],"name":"requestConsolidation","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"requestOwnershipHandover","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes[]","name":"pubKeys","type":"bytes[]"},{"internalType":"uint64[]","name":"amounts","type":"uint64[]"}],"name":"requestWithdrawal","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"revokeRoles","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"rewardRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"rolesOf","outputs":[{"internalType":"uint256","name":"roles","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newPrincipalRecipient","type":"address"}],"name":"setPrincipalRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawalSystemContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

67246:17174:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79500:114;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71834:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71135:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71240:40;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51037:111;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;50486:125;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52114:141;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74099:391;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;75873:908;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;78391:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;7630:630;;;:::i;:::-;;75373:75;;;;;;;;;;;;;:::i;:::-;;51486:362;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;71562:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;75130:71;;;;;;;;;;;;;:::i;:::-;;71189:46;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;50760:127;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70646:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;51913:136;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;78792:354;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;8345:466;;;:::i;:::-;;71666:37;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70541:46;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70592:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;7365:102;;;:::i;:::-;;71285:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10070:196;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;74622:397;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;77415:801;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;70700:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9002:724;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;6939:358;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71078:52;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10372:449;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;79500:114;79564:7;79587:12;:21;79600:7;79587:21;;;;;;;;;;;;;;;;79580:28;;79500:114;;;:::o;71834:37::-;;;;;;;;;;;;;:::o;71135:49::-;;;:::o;71240:40::-;;;:::o;51037:111::-;51109:31;51122:10;51134:5;51109:12;:31::i;:::-;51037:111;:::o;50486:125::-;11218:13;:11;:13::i;:::-;50579:24:::1;50591:4;50597:5;50579:11;:24::i;:::-;50486:125:::0;;:::o;52114:141::-;52193:4;52242:5;52233;52217:13;52225:4;52217:7;:13::i;:::-;:21;:30;52210:37;;52114:141;;;;:::o;74099:391::-;74306:9;74280:22;;:35;;;;;;;:::i;:::-;;;;;;;;74339:21;74322:47;;;74377:9;74396:6;;74411:22;;74442:9;;74460:17;74322:162;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74099:391;;;;;;;:::o;75873:908::-;70637:4;52944:25;52963:5;52944:18;:25::i;:::-;76068:1:::1;76044:13;;:20;;:25;:54;;;;76096:2;76073:13;;:20;;:25;76044:54;:98;;;;70882:2;76102:12;;:19;;:40;;76044:98;76040:141;;;76158:23;;;;;;;;;;;;;;76040:141;76190:20;76213:9;76190:32;;76229:11;76243:13;;:20;;76229:34;;76277:9;76272:354;76292:3;76288:1;:7;76272:354;;;76308:19;76330:54;76356:27;76330:25;:54::i;:::-;76308:76;;76411:12;76397:11;:26;76393:68;;;76432:29;;;;;;;;;;;;;;76393:68;76488:11;76472:27;;;;;:::i;:::-;;;76508:66;76530:13;;76544:1;76530:16;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;76548:12;;76562:11;76508:21;:66::i;:::-;76606:3;;;;;76299:327;76272:354;;;;76730:1;76715:12;:16;76711:64;;;76741:10;76733:28;;:42;76762:12;76733:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;76711:64;76033:748;;75873:908:::0;;;;;:::o;78391:295::-;70745:4;52944:25;52963:5;52944:18;:25::i;:::-;78506:14:::1;78529:11;78523:28;;;78560:4;78523:43;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;78506:60;;78573:43;78598:9;78609:6;78573:11;:24;;;;:43;;;;;:::i;:::-;78662:9;78630:50;;78649:11;78630:50;;;78673:6;78630:50;;;;;;:::i;:::-;;;;;;;;78499:187;78391:295:::0;;;:::o;7630:630::-;7725:15;7761:28;:26;:28::i;:::-;7743:46;;:15;:46;7725:64;;7961:19;7955:4;7948:33;8012:8;8006:4;7999:22;8069:7;8062:4;8056;8046:21;8039:38;8218:8;8171:45;8168:1;8165;8160:67;7861:381;7630:630::o;75373:75::-;75420:22;70828:1;75420:16;:22::i;:::-;75373:75::o;51486:362::-;51546:13;51692:15;51686:4;51679:29;51735:4;51729;51722:18;51824:4;51818;51808:21;51802:28;51793:37;;51486:362;;;:::o;71562:33::-;;;;;;;;;;;;:::o;75130:71::-;75173:22;70789:1;75173:16;:22::i;:::-;75130:71::o;71189:46::-;;;:::o;50760:127::-;11218:13;:11;:13::i;:::-;50854:25:::1;50867:4;50873:5;50854:12;:25::i;:::-;50760:127:::0;;:::o;70646:49::-;70691:4;70646:49;:::o;51913:136::-;51991:4;52040:1;52031:5;52015:13;52023:4;52015:7;:13::i;:::-;:21;:26;;52008:33;;51913:136;;;;:::o;78792:354::-;78843:14;78860:12;:21;78873:7;78860:21;;;;;;;;;;;;;;;;78843:38;;79015:6;78981:22;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79060:1;79036:12;:21;79049:7;79036:21;;;;;;;;;;;;;;;:25;;;;79068:31;79092:6;79068:7;:23;;;;:31;;;;:::i;:::-;79124:7;79113:27;;;79133:6;79113:27;;;;;;:::i;:::-;;;;;;;;78836:310;78792:354;:::o;8345:466::-;8551:19;8545:4;8538:33;8598:8;8592:4;8585:22;8651:1;8644:4;8638;8628:21;8621:32;8784:8;8738:44;8735:1;8732;8727:66;8345:466::o;71666:37::-;;;;:::o;70541:46::-;70583:4;70541:46;:::o;70592:49::-;70637:4;70592:49;:::o;7365:102::-;11218:13;:11;:13::i;:::-;7438:21:::1;7456:1;7438:9;:21::i;:::-;7365:102::o:0;71285:42::-;;;:::o;10070:196::-;10116:14;10231:15;10227:20;10221:27;10211:37;;10070:196;:::o;74622:397::-;70691:4;52944:25;52963:5;52944:18;:25::i;:::-;74774:1:::1;74741:35;;:21;:35;;::::0;74737:88:::1;;74794:23;;;;;;;;;;;;;;74737:88;74833:29;74865:18:::0;::::1;;;;;;;;;;74833:50;;74911:21;74890:18;::::0;:42:::1;;;;;;;;;;;;;;;;;;74991:21;74946:67;;74968:21;74946:67;;;;;;;;;;;;74730:289;74622:397:::0;;:::o;77415:801::-;70583:4;52944:25;52963:5;52944:18;:25::i;:::-;77590:7:::1;;:14;;77572:7;;:14;;:32;77568:68;;77613:23;;;;;;;;;;;;;;77568:68;77645:20;77668:9;77645:32;;77684:11;77698:7;;:14;;77684:28;;77726:9;77721:340;77741:3;77737:1;:7;77721:340;;;77757:19;77779:51;77805:24;77779:25;:51::i;:::-;77757:73;;77857:12;77843:11;:26;77839:68;;;77878:29;;;;;;;;;;;;;;77839:68;77934:11;77918:27;;;;;:::i;:::-;;;77954:55;77973:7;;77981:1;77973:10;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;77954:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;77985:7;;77993:1;77985:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;77997:11;77954:18;:55::i;:::-;78041:3;;;;;77748:313;77721:340;;;;78165:1;78150:12;:16;78146:64;;;78176:10;78168:28;;:42;78197:12;78168:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;78146:64;77561:655;;77415:801:::0;;;;;:::o;70700:49::-;70745:4;70700:49;:::o;9002:724::-;11218:13;:11;:13::i;:::-;9240:19:::1;9234:4;9227:33;9287:12;9281:4;9274:26;9350:4;9344;9334:21;9458:12;9452:19;9439:11;9436:36;9433:160;;;9505:10;9499:4;9492:24;9573:4;9567;9560:18;9433:160;9672:1;9658:12;9651:23;9156:529;9695:23;9705:12;9695:9;:23::i;:::-;9002:724:::0;:::o;6939:358::-;11218:13;:11;:13::i;:::-;7114:8:::1;7110:2;7106:17;7096:153;;7157:10;7151:4;7144:24;7229:4;7223;7216:18;7096:153;7270:19;7280:8;7270:9;:19::i;:::-;6939:358:::0;:::o;71078:52::-;;;:::o;10372:449::-;10495:14;10651:19;10645:4;10638:33;10698:12;10692:4;10685:26;10797:4;10791;10781:21;10775:28;10765:38;;10372:449;;;:::o;45088:119::-;45167:32;45180:4;45186:5;45193;45167:12;:32::i;:::-;45088:119;;:::o;5851:373::-;6071:15;6067:20;6061:27;6051:8;6048:41;6038:168;;6123:10;6117:4;6110:24;6186:4;6180;6173:18;6038:168;5851:373::o;44831:117::-;44909:31;44922:4;44928:5;44935:4;44909:12;:31::i;:::-;44831:117;;:::o;46026:819::-;46329:15;46325:20;46319:27;46309:8;46306:41;46296:531;;46424:15;46418:4;46411:29;46471:8;46465:4;46458:22;46677:5;46669:4;46663;46653:21;46647:28;46643:40;46633:179;;46721:10;46715:4;46708:24;46788:4;46782;46775:18;46633:179;46296:531;46026:819;:::o;79968:272::-;80057:7;80074;80083:19;80106:21;:32;;:36;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80073:69;;;;80154:2;80149:45;;80165:29;;;;;;;;;;;;;;80149:45;80226:6;80218:15;;;:::i;:::-;80210:24;;80203:31;;;;79968:272;;;:::o;80442:599::-;70882:2;80551:6;;:13;;:34;;:72;;;;70882:2;80589:6;;:13;;:34;;80551:72;80547:108;;;80632:23;;;;;;;;;;;;;;80547:108;80832:7;80845:27;:32;;80885:3;80903:6;;80911;;80890:28;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;80845:74;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80831:88;;;80931:2;80926:45;;80942:29;;;;;;;;;;;;;;80926:45;81028:6;;80985:50;;;;;;;:::i;:::-;;;;;;;;81020:6;;80985:50;;;;;;;:::i;:::-;;;;;;;;81008:10;80985:50;;;;;;;;;;;;80540:501;80442:599;;;;;:::o;22992:957::-;23158:2;23152:4;23145:16;23216:6;23210:4;23203:20;23282:34;23276:4;23269:48;23676:4;23670;23664;23658;23655:1;23648:5;23641;23636:45;23569:16;23562:24;23558:1;23551:4;23545:11;23542:18;23539:48;23453:247;23425:408;;23748:10;23742:4;23735:24;23813:4;23807;23800:18;23425:408;23860:1;23854:4;23847:15;22992:957;;;:::o;6460:112::-;6529:6;6555:9;6548:16;;6460:112;:::o;81765:2249::-;81897:22;81922:21;81897:46;;81950:37;81998:22;;;;;;;;;;;81990:31;;81950:71;;82028:29;82077;82060:14;:46;;;;:::i;:::-;82028:78;;82113:29;82175:3;82153:18;82145:27;;:33;;;;:::i;:::-;82113:65;;82270:24;82305:21;82387;82362;:46;;:76;;;;;82437:1;82412:22;;:26;82362:76;82358:621;;;82479:22;;82455:21;:46;82451:455;;;82612:22;;82593:41;;82721:22;;82697:21;:46;82681:62;;82451:455;;;82873:21;82854:40;;82451:455;82358:621;;;82948:21;82932:37;;82358:621;83031:17;83007:41;;:21;:41;83003:84;;;83057:30;;;;;;;;;;;;;;83003:84;83254:1;83235:16;:20;83231:77;;;83291:16;83257:51;;:22;;:51;;;;;;;:::i;:::-;;;;;;;;83231:77;83553:57;83561:18;;;;;;;;;;83581:16;83599:10;83553:7;:57::i;:::-;83640:51;83648:15;83665:13;83680:10;83640:7;:51::i;:::-;70828:1;83704:10;:18;83700:235;;83756:1;83737:16;:20;:41;;;;83777:1;83761:13;:17;83737:41;83733:195;;;83904:13;83885:16;83853:29;:48;;;;:::i;:::-;:64;;;;:::i;:::-;83820:22;;:98;;;;;;;;;;;;;;;;;;83733:195;83700:235;83948:60;83964:16;83982:13;83997:10;83948:60;;;;;;;;:::i;:::-;;;;;;;;81820:2194;;;;;;81765:2249;:::o;14411:340::-;14606:4;14599:5;14593:4;14586:5;14578:6;14574:2;14567:5;14562:49;14552:181;;14645:10;14639:4;14632:24;14713:4;14707;14700:18;14552:181;14411:340;;:::o;5284:506::-;5438:15;5434:20;5537:8;5533:2;5529:17;5525:2;5521:26;5509:38;;5685:8;5673:9;5667:16;5627:38;5624:1;5621;5616:78;5763:8;5752:9;5745:27;5402:381;5284:506;:::o;81089:542::-;70882:2;81185:6;:13;:34;81181:70;;81228:23;;;;;;;;;;;;;;81181:70;81425:8;81439:24;:29;;81476:3;81498:6;81506;81481:32;;;;;;;;;:::i;:::-;;;;;;;;;;;;;81439:75;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;81424:90;;;81526:3;81521:43;;81538:26;;;;;;;;;;;;;;81521:43;81610:6;81578:47;;;;;;:::i;:::-;;;;;;;;81598:10;81578:47;;;81618:6;81578:47;;;;;;:::i;:::-;;;;;;;;81174:457;81089:542;;;:::o;43707:986::-;43876:15;43870:4;43863:29;43919:4;43913;43906:18;43970:4;43964;43954:21;44050:8;44044:15;44159:5;44150:7;44147:18;44407:2;44397:62;;44450:5;44441:7;44437:19;44428:7;44424:33;44413:44;;44397:62;44533:7;44523:8;44516:25;44667:7;44659:4;44653:11;44649:2;44645:20;44613:30;44610:1;44607;44602:73;43848:838;;;43707:986;;;:::o;84020:397::-;84133:1;84118:12;:16;84114:298;;;70828:1;84149:10;:18;84145:260;;84236:12;84209;:23;84222:9;84209:23;;;;;;;;;;;;;;;;:39;;;;;;;:::i;:::-;;;;;;;;84145:260;;;70789:1;84268:10;:18;84264:141;;84299:39;84325:12;84299:9;:25;;;;:39;;;;:::i;:::-;84264:141;;;84372:23;;;;;;;;;;;;;;84264:141;84145:260;84114:298;84020:397;;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:329::-;900:6;949:2;937:9;928:7;924:23;920:32;917:119;;;955:79;;:::i;:::-;917:119;1075:1;1100:53;1145:7;1136:6;1125:9;1121:22;1100:53;:::i;:::-;1090:63;;1046:117;841:329;;;;:::o;1176:77::-;1213:7;1242:5;1231:16;;1176:77;;;:::o;1259:118::-;1346:24;1364:5;1346:24;:::i;:::-;1341:3;1334:37;1259:118;;:::o;1383:222::-;1476:4;1514:2;1503:9;1499:18;1491:26;;1527:71;1595:1;1584:9;1580:17;1571:6;1527:71;:::i;:::-;1383:222;;;;:::o;1611:118::-;1648:7;1688:34;1681:5;1677:46;1666:57;;1611:118;;;:::o;1735:::-;1822:24;1840:5;1822:24;:::i;:::-;1817:3;1810:37;1735:118;;:::o;1859:222::-;1952:4;1990:2;1979:9;1975:18;1967:26;;2003:71;2071:1;2060:9;2056:17;2047:6;2003:71;:::i;:::-;1859:222;;;;:::o;2087:118::-;2174:24;2192:5;2174:24;:::i;:::-;2169:3;2162:37;2087:118;;:::o;2211:222::-;2304:4;2342:2;2331:9;2327:18;2319:26;;2355:71;2423:1;2412:9;2408:17;2399:6;2355:71;:::i;:::-;2211:222;;;;:::o;2439:122::-;2512:24;2530:5;2512:24;:::i;:::-;2505:5;2502:35;2492:63;;2551:1;2548;2541:12;2492:63;2439:122;:::o;2567:139::-;2613:5;2651:6;2638:20;2629:29;;2667:33;2694:5;2667:33;:::i;:::-;2567:139;;;;:::o;2712:329::-;2771:6;2820:2;2808:9;2799:7;2795:23;2791:32;2788:119;;;2826:79;;:::i;:::-;2788:119;2946:1;2971:53;3016:7;3007:6;2996:9;2992:22;2971:53;:::i;:::-;2961:63;;2917:117;2712:329;;;;:::o;3047:474::-;3115:6;3123;3172:2;3160:9;3151:7;3147:23;3143:32;3140:119;;;3178:79;;:::i;:::-;3140:119;3298:1;3323:53;3368:7;3359:6;3348:9;3344:22;3323:53;:::i;:::-;3313:63;;3269:117;3425:2;3451:53;3496:7;3487:6;3476:9;3472:22;3451:53;:::i;:::-;3441:63;;3396:118;3047:474;;;;;:::o;3527:90::-;3561:7;3604:5;3597:13;3590:21;3579:32;;3527:90;;;:::o;3623:109::-;3704:21;3719:5;3704:21;:::i;:::-;3699:3;3692:34;3623:109;;:::o;3738:210::-;3825:4;3863:2;3852:9;3848:18;3840:26;;3876:65;3938:1;3927:9;3923:17;3914:6;3876:65;:::i;:::-;3738:210;;;;:::o;3954:117::-;4063:1;4060;4053:12;4077:117;4186:1;4183;4176:12;4200:117;4309:1;4306;4299:12;4336:552;4393:8;4403:6;4453:3;4446:4;4438:6;4434:17;4430:27;4420:122;;4461:79;;:::i;:::-;4420:122;4574:6;4561:20;4551:30;;4604:18;4596:6;4593:30;4590:117;;;4626:79;;:::i;:::-;4590:117;4740:4;4732:6;4728:17;4716:29;;4794:3;4786:4;4778:6;4774:17;4764:8;4760:32;4757:41;4754:128;;;4801:79;;:::i;:::-;4754:128;4336:552;;;;;:::o;4894:77::-;4931:7;4960:5;4949:16;;4894:77;;;:::o;4977:122::-;5050:24;5068:5;5050:24;:::i;:::-;5043:5;5040:35;5030:63;;5089:1;5086;5079:12;5030:63;4977:122;:::o;5105:139::-;5151:5;5189:6;5176:20;5167:29;;5205:33;5232:5;5205:33;:::i;:::-;5105:139;;;;:::o;5250:1359::-;5369:6;5377;5385;5393;5401;5409;5417;5466:3;5454:9;5445:7;5441:23;5437:33;5434:120;;;5473:79;;:::i;:::-;5434:120;5621:1;5610:9;5606:17;5593:31;5651:18;5643:6;5640:30;5637:117;;;5673:79;;:::i;:::-;5637:117;5786:64;5842:7;5833:6;5822:9;5818:22;5786:64;:::i;:::-;5768:82;;;;5564:296;5927:2;5916:9;5912:18;5899:32;5958:18;5950:6;5947:30;5944:117;;;5980:79;;:::i;:::-;5944:117;6093:64;6149:7;6140:6;6129:9;6125:22;6093:64;:::i;:::-;6075:82;;;;5870:297;6234:2;6223:9;6219:18;6206:32;6265:18;6257:6;6254:30;6251:117;;;6287:79;;:::i;:::-;6251:117;6400:64;6456:7;6447:6;6436:9;6432:22;6400:64;:::i;:::-;6382:82;;;;6177:297;6513:2;6539:53;6584:7;6575:6;6564:9;6560:22;6539:53;:::i;:::-;6529:63;;6484:118;5250:1359;;;;;;;;;;:::o;6630:579::-;6714:8;6724:6;6774:3;6767:4;6759:6;6755:17;6751:27;6741:122;;6782:79;;:::i;:::-;6741:122;6895:6;6882:20;6872:30;;6925:18;6917:6;6914:30;6911:117;;;6947:79;;:::i;:::-;6911:117;7061:4;7053:6;7049:17;7037:29;;7115:3;7107:4;7099:6;7095:17;7085:8;7081:32;7078:41;7075:128;;;7122:79;;:::i;:::-;7075:128;6630:579;;;;;:::o;7215:924::-;7332:6;7340;7348;7356;7405:2;7393:9;7384:7;7380:23;7376:32;7373:119;;;7411:79;;:::i;:::-;7373:119;7559:1;7548:9;7544:17;7531:31;7589:18;7581:6;7578:30;7575:117;;;7611:79;;:::i;:::-;7575:117;7724:91;7807:7;7798:6;7787:9;7783:22;7724:91;:::i;:::-;7706:109;;;;7502:323;7892:2;7881:9;7877:18;7864:32;7923:18;7915:6;7912:30;7909:117;;;7945:79;;:::i;:::-;7909:117;8058:64;8114:7;8105:6;8094:9;8090:22;8058:64;:::i;:::-;8040:82;;;;7835:297;7215:924;;;;;;;:::o;8145:474::-;8213:6;8221;8270:2;8258:9;8249:7;8245:23;8241:32;8238:119;;;8276:79;;:::i;:::-;8238:119;8396:1;8421:53;8466:7;8457:6;8446:9;8442:22;8421:53;:::i;:::-;8411:63;;8367:117;8523:2;8549:53;8594:7;8585:6;8574:9;8570:22;8549:53;:::i;:::-;8539:63;;8494:118;8145:474;;;;;:::o;8625:101::-;8661:7;8701:18;8694:5;8690:30;8679:41;;8625:101;;;:::o;8732:115::-;8817:23;8834:5;8817:23;:::i;:::-;8812:3;8805:36;8732:115;;:::o;8853:218::-;8944:4;8982:2;8971:9;8967:18;8959:26;;8995:69;9061:1;9050:9;9046:17;9037:6;8995:69;:::i;:::-;8853:218;;;;:::o;9093:567::-;9165:8;9175:6;9225:3;9218:4;9210:6;9206:17;9202:27;9192:122;;9233:79;;:::i;:::-;9192:122;9346:6;9333:20;9323:30;;9376:18;9368:6;9365:30;9362:117;;;9398:79;;:::i;:::-;9362:117;9512:4;9504:6;9500:17;9488:29;;9566:3;9558:4;9550:6;9546:17;9536:8;9532:32;9529:41;9526:128;;;9573:79;;:::i;:::-;9526:128;9093:567;;;;;:::o;9666:954::-;9798:6;9806;9814;9822;9871:2;9859:9;9850:7;9846:23;9842:32;9839:119;;;9877:79;;:::i;:::-;9839:119;10025:1;10014:9;10010:17;9997:31;10055:18;10047:6;10044:30;10041:117;;;10077:79;;:::i;:::-;10041:117;10190:91;10273:7;10264:6;10253:9;10249:22;10190:91;:::i;:::-;10172:109;;;;9968:323;10358:2;10347:9;10343:18;10330:32;10389:18;10381:6;10378:30;10375:117;;;10411:79;;:::i;:::-;10375:117;10524:79;10595:7;10586:6;10575:9;10571:22;10524:79;:::i;:::-;10506:97;;;;10301:312;9666:954;;;;;;;:::o;10626:180::-;10674:77;10671:1;10664:88;10771:4;10768:1;10761:15;10795:4;10792:1;10785:15;10812:191;10852:3;10871:20;10889:1;10871:20;:::i;:::-;10866:25;;10905:20;10923:1;10905:20;:::i;:::-;10900:25;;10948:1;10945;10941:9;10934:16;;10969:3;10966:1;10963:10;10960:36;;;10976:18;;:::i;:::-;10960:36;10812:191;;;;:::o;11009:168::-;11092:11;11126:6;11121:3;11114:19;11166:4;11161:3;11157:14;11142:29;;11009:168;;;;:::o;11183:146::-;11280:6;11275:3;11270;11257:30;11321:1;11312:6;11307:3;11303:16;11296:27;11183:146;;;:::o;11335:102::-;11376:6;11427:2;11423:7;11418:2;11411:5;11407:14;11403:28;11393:38;;11335:102;;;:::o;11465:314::-;11561:3;11582:70;11645:6;11640:3;11582:70;:::i;:::-;11575:77;;11662:56;11711:6;11706:3;11699:5;11662:56;:::i;:::-;11743:29;11765:6;11743:29;:::i;:::-;11738:3;11734:39;11727:46;;11465:314;;;;;:::o;11785:118::-;11872:24;11890:5;11872:24;:::i;:::-;11867:3;11860:37;11785:118;;:::o;11909:874::-;12170:4;12208:3;12197:9;12193:19;12185:27;;12258:9;12252:4;12248:20;12244:1;12233:9;12229:17;12222:47;12286:86;12367:4;12358:6;12350;12286:86;:::i;:::-;12278:94;;12419:9;12413:4;12409:20;12404:2;12393:9;12389:18;12382:48;12447:86;12528:4;12519:6;12511;12447:86;:::i;:::-;12439:94;;12580:9;12574:4;12570:20;12565:2;12554:9;12550:18;12543:48;12608:86;12689:4;12680:6;12672;12608:86;:::i;:::-;12600:94;;12704:72;12772:2;12761:9;12757:18;12748:6;12704:72;:::i;:::-;11909:874;;;;;;;;;;:::o;12789:194::-;12829:4;12849:20;12867:1;12849:20;:::i;:::-;12844:25;;12883:20;12901:1;12883:20;:::i;:::-;12878:25;;12927:1;12924;12920:9;12912:17;;12951:1;12945:4;12942:11;12939:37;;;12956:18;;:::i;:::-;12939:37;12789:194;;;;:::o;12989:180::-;13037:77;13034:1;13027:88;13134:4;13131:1;13124:15;13158:4;13155:1;13148:15;13175:117;13284:1;13281;13274:12;13298:117;13407:1;13404;13397:12;13421:117;13530:1;13527;13520:12;13544:724;13621:4;13627:6;13683:11;13670:25;13783:1;13777:4;13773:12;13762:8;13746:14;13742:29;13738:48;13718:18;13714:73;13704:168;;13791:79;;:::i;:::-;13704:168;13903:18;13893:8;13889:33;13881:41;;13955:4;13942:18;13932:28;;13983:18;13975:6;13972:30;13969:117;;;14005:79;;:::i;:::-;13969:117;14113:2;14107:4;14103:13;14095:21;;14170:4;14162:6;14158:17;14142:14;14138:38;14132:4;14128:49;14125:136;;;14180:79;;:::i;:::-;14125:136;13634:634;13544:724;;;;;:::o;14274:143::-;14331:5;14362:6;14356:13;14347:22;;14378:33;14405:5;14378:33;:::i;:::-;14274:143;;;;:::o;14423:351::-;14493:6;14542:2;14530:9;14521:7;14517:23;14513:32;14510:119;;;14548:79;;:::i;:::-;14510:119;14668:1;14693:64;14749:7;14740:6;14729:9;14725:22;14693:64;:::i;:::-;14683:74;;14639:128;14423:351;;;;:::o;14780:120::-;14852:23;14869:5;14852:23;:::i;:::-;14845:5;14842:34;14832:62;;14890:1;14887;14880:12;14832:62;14780:120;:::o;14906:137::-;14951:5;14989:6;14976:20;14967:29;;15005:32;15031:5;15005:32;:::i;:::-;14906:137;;;;:::o;15049:327::-;15107:6;15156:2;15144:9;15135:7;15131:23;15127:32;15124:119;;;15162:79;;:::i;:::-;15124:119;15282:1;15307:52;15351:7;15342:6;15331:9;15327:22;15307:52;:::i;:::-;15297:62;;15253:116;15049:327;;;;:::o;15382:147::-;15483:11;15520:3;15505:18;;15382:147;;;;:::o;15535:114::-;;:::o;15655:398::-;15814:3;15835:83;15916:1;15911:3;15835:83;:::i;:::-;15828:90;;15927:93;16016:3;15927:93;:::i;:::-;16045:1;16040:3;16036:11;16029:18;;15655:398;;;:::o;16059:379::-;16243:3;16265:147;16408:3;16265:147;:::i;:::-;16258:154;;16429:3;16422:10;;16059:379;;;:::o;16444:98::-;16495:6;16529:5;16523:12;16513:22;;16444:98;;;:::o;16548:116::-;16599:4;16622:3;16614:11;;16652:4;16647:3;16643:14;16635:22;;16548:116;;;:::o;16670:154::-;16713:11;16749:29;16773:3;16767:10;16749:29;:::i;:::-;16812:5;16788:29;;16725:99;16670:154;;;:::o;16830:107::-;16874:8;16924:5;16918:4;16914:16;16893:37;;16830:107;;;;:::o;16943:594::-;17027:5;17058:38;17090:5;17058:38;:::i;:::-;17121:5;17148:40;17182:5;17148:40;:::i;:::-;17136:52;;17207:35;17233:8;17207:35;:::i;:::-;17198:44;;17266:2;17258:6;17255:14;17252:278;;;17337:169;17422:66;17392:6;17388:2;17384:15;17381:1;17377:23;17337:169;:::i;:::-;17314:5;17293:227;17284:236;;17252:278;17033:504;;16943:594;;;:::o;17565:327::-;17679:3;17700:88;17781:6;17776:3;17700:88;:::i;:::-;17693:95;;17798:56;17847:6;17842:3;17835:5;17798:56;:::i;:::-;17879:6;17874:3;17870:16;17863:23;;17565:327;;;;;:::o;17898:467::-;18094:3;18116:103;18215:3;18206:6;18198;18116:103;:::i;:::-;18109:110;;18236:103;18335:3;18326:6;18318;18236:103;:::i;:::-;18229:110;;18356:3;18349:10;;17898:467;;;;;;;:::o;18371:246::-;18452:1;18462:113;18476:6;18473:1;18470:13;18462:113;;;18561:1;18556:3;18552:11;18546:18;18542:1;18537:3;18533:11;18526:39;18498:2;18495:1;18491:10;18486:15;;18462:113;;;18609:1;18600:6;18595:3;18591:16;18584:27;18433:184;18371:246;;;:::o;18623:386::-;18727:3;18755:38;18787:5;18755:38;:::i;:::-;18809:88;18890:6;18885:3;18809:88;:::i;:::-;18802:95;;18906:65;18964:6;18959:3;18952:4;18945:5;18941:16;18906:65;:::i;:::-;18996:6;18991:3;18987:16;18980:23;;18731:278;18623:386;;;;:::o;19015:271::-;19145:3;19167:93;19256:3;19247:6;19167:93;:::i;:::-;19160:100;;19277:3;19270:10;;19015:271;;;;:::o;19292:291::-;19432:3;19454:103;19553:3;19544:6;19536;19454:103;:::i;:::-;19447:110;;19574:3;19567:10;;19292:291;;;;;:::o;19589:410::-;19629:7;19652:20;19670:1;19652:20;:::i;:::-;19647:25;;19686:20;19704:1;19686:20;:::i;:::-;19681:25;;19741:1;19738;19734:9;19763:30;19781:11;19763:30;:::i;:::-;19752:41;;19942:1;19933:7;19929:15;19926:1;19923:22;19903:1;19896:9;19876:83;19853:139;;19972:18;;:::i;:::-;19853:139;19637:362;19589:410;;;;:::o;20005:442::-;20154:4;20192:2;20181:9;20177:18;20169:26;;20205:71;20273:1;20262:9;20258:17;20249:6;20205:71;:::i;:::-;20286:72;20354:2;20343:9;20339:18;20330:6;20286:72;:::i;:::-;20368;20436:2;20425:9;20421:18;20412:6;20368:72;:::i;:::-;20005:442;;;;;;:::o;20453:96::-;20487:8;20536:5;20531:3;20527:15;20506:36;;20453:96;;;:::o;20555:94::-;20593:7;20622:21;20637:5;20622:21;:::i;:::-;20611:32;;20555:94;;;:::o;20655:153::-;20758:43;20777:23;20794:5;20777:23;:::i;:::-;20758:43;:::i;:::-;20753:3;20746:56;20655:153;;:::o;20814:407::-;20970:3;20992:93;21081:3;21072:6;20992:93;:::i;:::-;20985:100;;21095:73;21164:3;21155:6;21095:73;:::i;:::-;21193:1;21188:3;21184:11;21177:18;;21212:3;21205:10;;20814:407;;;;;:::o;21227:60::-;21255:3;21276:5;21269:12;;21227:60;;;:::o;21293:140::-;21342:9;21375:52;21393:33;21402:23;21419:5;21402:23;:::i;:::-;21393:33;:::i;:::-;21375:52;:::i;:::-;21362:65;;21293:140;;;:::o;21439:129::-;21525:36;21555:5;21525:36;:::i;:::-;21520:3;21513:49;21439:129;;:::o;21574:220::-;21666:4;21704:2;21693:9;21689:18;21681:26;;21717:70;21784:1;21773:9;21769:17;21760:6;21717:70;:::i;:::-;21574:220;;;;:::o

ipfs://817927d3197eeb8430978a922bcfef4412fe39366077fd1f40603cbd14c5b2f6