Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// File: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

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

// File: @openzeppelin/contracts/interfaces/draft-IERC6093.sol


// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the value of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves a `value` amount of tokens from the caller's account to `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, uint256 value) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the
     * caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 value) external returns (bool);

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to` using the
     * allowance mechanism. `value` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 value) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;





/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

    mapping(address account => mapping(address spender => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `value`.
     */
    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, value);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal virtual  {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     * ```
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// File: contracts/FORTUNA.sol


pragma solidity ^0.8.25;






contract FORTUNA is ERC20, Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using Address for address;

    address public vault;
    address public winner;
    address public ownerCntr;
    uint256 public taxPercentage = 1; // 1%
    bool public minted = false; // set the defualt minted state
    uint256 public constant TOTAL_SUPPLY = 100_000_000 * 10**18; // 100 million tokens
    uint256 public constant VAULT_THRESHOLD = 10_000 * 10**18; // 10,000 tokens
    uint256 public constant MIN_PARTICIPATION_BALANCE = 500 * 10**18; // Minimum balance required for lottery participation

    mapping(address => bool) public isExcludedFromTax;
    mapping(address => bool) public lotteryRestriction;
    mapping(address => bool) internal isHolder;
    mapping(address => uint) internal atIndex;

    // Array to store addresses of token holders
    address[] public holders;
    uint public indexSender;

    event LotteryWinner(address indexed winner, uint256 lotteryAmount);
    event HoldersArray(uint length);

    constructor(address _vaultAddress) ERC20("FORTUNA", "FRTN8") Ownable(msg.sender) {
        vault = _vaultAddress;
        ownerCntr = msg.sender;
        // Exclude from tax and lottery privilige owner and vault
        lotteryRestriction[vault] = true;
        lotteryRestriction[ownerCntr] = true;
        isExcludedFromTax[vault] = true;
        isExcludedFromTax[ownerCntr] = true;
    }

function mint() external onlyOwner {
    require(!minted, "Mint function can only be called once");
    _mint(msg.sender, TOTAL_SUPPLY);
    minted = true;
}

    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal override {
        require(!(recipient == vault || recipient == ownerCntr), "Cannot send to vault or owner");
        uint256 taxAmount = 0;
        if (!isExcludedFromTax[sender]) {
            taxAmount = amount.mul(taxPercentage).div(100);
            super._transfer(sender, vault, taxAmount);
        }
        super._transfer(sender, recipient, amount.sub(taxAmount));
        // Remove sender from holders array if they have less than required minimum
        if (balanceOf(sender) < MIN_PARTICIPATION_BALANCE && isHolder[sender]) {
                     
                    indexSender = atIndex[sender];

                    if(holders[indexSender] == holders[holders.length - 1]){
                     holders.pop();
                     isHolder[sender] = false;
                    }else{

                     address tempA;
                     tempA = holders[holders.length - 1];
                     holders[holders.length - 1] = holders[indexSender];
                     holders[indexSender] = tempA;
                     atIndex[tempA] = atIndex[holders[holders.length - 1]];
                     holders.pop();
                     isHolder[sender] = false;
                    }

             }  

        // Add recipient to holders array if they're not already in it
        if (balanceOf(recipient) >= MIN_PARTICIPATION_BALANCE && !isHolder[recipient]) {
                holders.push(recipient);
                isHolder[recipient] = true;
                atIndex[recipient] = holders.length-1;
        }

        // Check if vault balance exceeds threshold for lottery
        if (balanceOf(vault) >= VAULT_THRESHOLD) {
            triggerLottery();
        }
    }

    function triggerLottery() private nonReentrant {
        require(holders.length > 0, "No holders with enough tokens");
        // Select a random index
        uint256 index = uint256(keccak256(abi.encodePacked(block.timestamp, block.prevrandao))) % holders.length;
        uint256 vaultBalance = balanceOf(vault);
        require(vaultBalance >= VAULT_THRESHOLD, "Vault balance is not enough for lottery");
        uint256 lotteryAmount = vaultBalance ; //  vault balance
        //send vault contents to a random selected address
        winner = holders[index];
        if(lotteryRestriction[winner]==false){
        _transfer(vault, holders[index], lotteryAmount);
        emit LotteryWinner(winner, lotteryAmount);
        }else{triggerLottery();}
    }

    function holdersLength() external onlyOwner returns (uint) {
        emit HoldersArray(holders.length);
        return holders.length;
    }

    function setVault(address _vault) external onlyOwner {
        vault = _vault;
    }

    function setTaxPercentage(uint256 _taxPercentage) external onlyOwner {
        require(_taxPercentage <= 10, "Tax percentage exceeds 10%");
        taxPercentage = _taxPercentage;
    }

    function excludeFromTax(address account) external onlyOwner {
        isExcludedFromTax[account] = true;
    }

    function includeInTax(address account) external onlyOwner {
        isExcludedFromTax[account] = false;
    }

    function setlotteryRestriction(address account, bool restricted) external onlyOwner {
        lotteryRestriction[account] = restricted;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_vaultAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"length","type":"uint256"}],"name":"HoldersArray","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"winner","type":"address"},{"indexed":false,"internalType":"uint256","name":"lotteryAmount","type":"uint256"}],"name":"LotteryWinner","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"MIN_PARTICIPATION_BALANCE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOTAL_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VAULT_THRESHOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"holders","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"holdersLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"includeInTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"indexSender","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isExcludedFromTax","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"lotteryRestriction","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ownerCntr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_taxPercentage","type":"uint256"}],"name":"setTaxPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vault","type":"address"}],"name":"setVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"restricted","type":"bool"}],"name":"setlotteryRestriction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"winner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"}]

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

0000000000000000000000001efcd4ca52dfee56f28079d42118e8aa54004f4e

-----Decoded View---------------
Arg [0] : _vaultAddress (address): 0x1eFcd4ca52dfee56F28079D42118e8Aa54004F4E

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000001efcd4ca52dfee56f28079d42118e8aa54004f4e

42516:5087:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46775:143;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33103:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35396:190;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43975:161;;;:::i;:::-;;34205:99;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36164:249;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43396:24;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34056:84;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42773:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47216:112;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;46926:86;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;47020:188;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;34367:118;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26716:103;;;:::i;:::-;;42926:57;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26041:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42838:59;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33313:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47455:143;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43190:50;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34690:182;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42728:32;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43427:23;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43134:49;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42697:24;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34935:142;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42669:21;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;47336:111;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;26974:220;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;43007:64;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42642:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;46775:143;46828:4;25927:13;:11;:13::i;:::-;46850:28:::1;46863:7;:14;;;;46850:28;;;;;;:::i;:::-;;;;;;;;46896:7;:14;;;;46889:21;;46775:143:::0;:::o;33103:91::-;33148:13;33181:5;33174:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33103:91;:::o;35396:190::-;35469:4;35486:13;35502:12;:10;:12::i;:::-;35486:28;;35525:31;35534:5;35541:7;35550:5;35525:8;:31::i;:::-;35574:4;35567:11;;;35396:190;;;;:::o;43975:161::-;25927:13;:11;:13::i;:::-;44026:6:::1;;;;;;;;;;;44025:7;44017:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;44081:31;44087:10;42877:20;44081:5;:31::i;:::-;44128:4;44119:6;;:13;;;;;;;;;;;;;;;;;;43975:161::o:0;34205:99::-;34257:7;34284:12;;34277:19;;34205:99;:::o;36164:249::-;36251:4;36268:15;36286:12;:10;:12::i;:::-;36268:30;;36309:37;36325:4;36331:7;36340:5;36309:15;:37::i;:::-;36357:26;36367:4;36373:2;36377:5;36357:9;:26::i;:::-;36401:4;36394:11;;;36164:249;;;;;:::o;43396:24::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;34056:84::-;34105:5;34130:2;34123:9;;34056:84;:::o;42773:26::-;;;;;;;;;;;;;:::o;47216:112::-;25927:13;:11;:13::i;:::-;47316:4:::1;47287:17;:26;47305:7;47287:26;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;47216:112:::0;:::o;46926:86::-;25927:13;:11;:13::i;:::-;46998:6:::1;46990:5;;:14;;;;;;;;;;;;;;;;;;46926:86:::0;:::o;47020:188::-;25927:13;:11;:13::i;:::-;47126:2:::1;47108:14;:20;;47100:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;47186:14;47170:13;:30;;;;47020:188:::0;:::o;34367:118::-;34432:7;34459:9;:18;34469:7;34459:18;;;;;;;;;;;;;;;;34452:25;;34367:118;;;:::o;26716:103::-;25927:13;:11;:13::i;:::-;26781:30:::1;26808:1;26781:18;:30::i;:::-;26716:103::o:0;42926:57::-;42968:15;42926:57;:::o;26041:87::-;26087:7;26114:6;;;;;;;;;;;26107:13;;26041:87;:::o;42838:59::-;42877:20;42838:59;:::o;33313:95::-;33360:13;33393:7;33386:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33313:95;:::o;47455:143::-;25927:13;:11;:13::i;:::-;47580:10:::1;47550:18;:27;47569:7;47550:27;;;;;;;;;;;;;;;;:40;;;;;;;;;;;;;;;;;;47455:143:::0;;:::o;43190:50::-;;;;;;;;;;;;;;;;;;;;;;:::o;34690:182::-;34759:4;34776:13;34792:12;:10;:12::i;:::-;34776:28;;34815:27;34825:5;34832:2;34836:5;34815:9;:27::i;:::-;34860:4;34853:11;;;34690:182;;;;:::o;42728:32::-;;;;:::o;43427:23::-;;;;:::o;43134:49::-;;;;;;;;;;;;;;;;;;;;;;:::o;42697:24::-;;;;;;;;;;;;;:::o;34935:142::-;35015:7;35042:11;:18;35054:5;35042:18;;;;;;;;;;;;;;;:27;35061:7;35042:27;;;;;;;;;;;;;;;;35035:34;;34935:142;;;;:::o;42669:21::-;;;;;;;;;;;;;:::o;47336:111::-;25927:13;:11;:13::i;:::-;47434:5:::1;47405:17;:26;47423:7;47405:26;;;;;;;;;;;;;;;;:34;;;;;;;;;;;;;;;;;;47336:111:::0;:::o;26974:220::-;25927:13;:11;:13::i;:::-;27079:1:::1;27059:22;;:8;:22;;::::0;27055:93:::1;;27133:1;27105:31;;;;;;;;;;;:::i;:::-;;;;;;;;27055:93;27158:28;27177:8;27158:18;:28::i;:::-;26974:220:::0;:::o;43007:64::-;43059:12;43007:64;:::o;42642:20::-;;;;;;;;;;;;;:::o;26206:166::-;26277:12;:10;:12::i;:::-;26266:23;;:7;:5;:7::i;:::-;:23;;;26262:103;;26340:12;:10;:12::i;:::-;26313:40;;;;;;;;;;;:::i;:::-;;;;;;;;26262:103;26206:166::o;24050:98::-;24103:7;24130:10;24123:17;;24050:98;:::o;40232:130::-;40317:37;40326:5;40333:7;40342:5;40349:4;40317:8;:37::i;:::-;40232:130;;;:::o;38927:213::-;39017:1;38998:21;;:7;:21;;;38994:93;;39072:1;39043:32;;;;;;;;;;;:::i;:::-;;;;;;;;38994:93;39097:35;39113:1;39117:7;39126:5;39097:7;:35::i;:::-;38927:213;;:::o;41948:487::-;42048:24;42075:25;42085:5;42092:7;42075:9;:25::i;:::-;42048:52;;42135:17;42115:16;:37;42111:317;;42192:5;42173:16;:24;42169:132;;;42252:7;42261:16;42279:5;42225:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;42169:132;42344:57;42353:5;42360:7;42388:5;42369:16;:24;42395:5;42344:8;:57::i;:::-;42111:317;42037:398;41948:487;;;:::o;44144:1844::-;44300:5;;;;;;;;;;;44287:18;;:9;:18;;;:44;;;;44322:9;;;;;;;;;;;44309:22;;:9;:22;;;44287:44;44285:47;44277:89;;;;;;;;;;;;:::i;:::-;;;;;;;;;44377:17;44414;:25;44432:6;44414:25;;;;;;;;;;;;;;;;;;;;;;;;;44409:161;;44468:34;44498:3;44468:25;44479:13;;44468:6;:10;;:25;;;;:::i;:::-;:29;;:34;;;;:::i;:::-;44456:46;;44517:41;44533:6;44541:5;;;;;;;;;;;44548:9;44517:15;:41::i;:::-;44409:161;44580:57;44596:6;44604:9;44615:21;44626:9;44615:6;:10;;:21;;;;:::i;:::-;44580:15;:57::i;:::-;43059:12;44737:17;44747:6;44737:9;:17::i;:::-;:45;:65;;;;;44786:8;:16;44795:6;44786:16;;;;;;;;;;;;;;;;;;;;;;;;;44737:65;44733:767;;;44864:7;:15;44872:6;44864:15;;;;;;;;;;;;;;;;44850:11;:29;;;;44931:7;44956:1;44939:7;:14;;;;:18;;;;:::i;:::-;44931:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;44907:51;;:7;44915:11;;44907:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:51;;;44904:578;;44983:7;:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;45039:5;45020:8;:16;45029:6;45020:16;;;;;;;;;;;;;;;;:24;;;;;;;;;;;;;;;;;;44904:578;;;45098:13;45143:7;45168:1;45151:7;:14;;;;:18;;;;:::i;:::-;45143:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45135:35;;45224:7;45232:11;;45224:20;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45194:7;45219:1;45202:7;:14;;;;:18;;;;:::i;:::-;45194:27;;;;;;;;:::i;:::-;;;;;;;;;;:50;;;;;;;;;;;;;;;;;;45291:5;45268:7;45276:11;;45268:20;;;;;;;;:::i;:::-;;;;;;;;;;:28;;;;;;;;;;;;;;;;;;45337:7;:36;45345:7;45370:1;45353:7;:14;;;;:18;;;;:::i;:::-;45345:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;45337:36;;;;;;;;;;;;;;;;45320:7;:14;45328:5;45320:14;;;;;;;;;;;;;;;:53;;;;45397:7;:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;45453:5;45434:8;:16;45443:6;45434:16;;;;;;;;;;;;;;;;:24;;;;;;;;;;;;;;;;;;45072:410;44904:578;44733:767;43059:12;45590:20;45600:9;45590;:20::i;:::-;:49;;:73;;;;;45644:8;:19;45653:9;45644:19;;;;;;;;;;;;;;;;;;;;;;;;;45643:20;45590:73;45586:234;;;45684:7;45697:9;45684:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45748:4;45726:8;:19;45735:9;45726:19;;;;;;;;;;;;;;;;:26;;;;;;;;;;;;;;;;;;45807:1;45792:7;:14;;;;:16;;;;:::i;:::-;45771:7;:18;45779:9;45771:18;;;;;;;;;;;;;;;:37;;;;45586:234;42968:15;45901:16;45911:5;;;;;;;;;;;45901:9;:16::i;:::-;:35;45897:84;;45953:16;:14;:16::i;:::-;45897:84;44266:1722;44144:1844;;;:::o;27354:191::-;27428:16;27447:6;;;;;;;;;;;27428:25;;27473:8;27464:6;;:17;;;;;;;;;;;;;;;;;;27528:8;27497:40;;27518:8;27497:40;;;;;;;;;;;;27417:128;27354:191;:::o;41213:443::-;41343:1;41326:19;;:5;:19;;;41322:91;;41398:1;41369:32;;;;;;;;;;;:::i;:::-;;;;;;;;41322:91;41446:1;41427:21;;:7;:21;;;41423:92;;41500:1;41472:31;;;;;;;;;;;:::i;:::-;;;;;;;;41423:92;41555:5;41525:11;:18;41537:5;41525:18;;;;;;;;;;;;;;;:27;41544:7;41525:27;;;;;;;;;;;;;;;:35;;;;41575:9;41571:78;;;41622:7;41606:31;;41615:5;41606:31;;;41631:5;41606:31;;;;;;:::i;:::-;;;;;;;;41571:78;41213:443;;;;:::o;37439:1135::-;37545:1;37529:18;;:4;:18;;;37525:552;;37683:5;37667:12;;:21;;;;;;;:::i;:::-;;;;;;;;37525:552;;;37721:19;37743:9;:15;37753:4;37743:15;;;;;;;;;;;;;;;;37721:37;;37791:5;37777:11;:19;37773:117;;;37849:4;37855:11;37868:5;37824:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;37773:117;38045:5;38031:11;:19;38013:9;:15;38023:4;38013:15;;;;;;;;;;;;;;;:37;;;;37706:371;37525:552;38107:1;38093:16;;:2;:16;;;38089:435;;38275:5;38259:12;;:21;;;;;;;;;;;38089:435;;;38492:5;38475:9;:13;38485:2;38475:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;38089:435;38556:2;38541:25;;38550:4;38541:25;;;38560:5;38541:25;;;;;;:::i;:::-;;;;;;;;37439:1135;;;:::o;10060:98::-;10118:7;10149:1;10145;:5;;;;:::i;:::-;10138:12;;10060:98;;;;:::o;10459:::-;10517:7;10548:1;10544;:5;;;;:::i;:::-;10537:12;;10459:98;;;;:::o;36798:317::-;36907:1;36891:18;;:4;:18;;;36887:88;;36960:1;36933:30;;;;;;;;;;;:::i;:::-;;;;;;;;36887:88;37003:1;36989:16;;:2;:16;;;36985:88;;37058:1;37029:32;;;;;;;;;;;:::i;:::-;;;;;;;;36985:88;37083:24;37091:4;37097:2;37101:5;37083:7;:24::i;:::-;36798:317;;;:::o;9703:98::-;9761:7;9792:1;9788;:5;;;;:::i;:::-;9781:12;;9703:98;;;;:::o;45996:771::-;15730:21;:19;:21::i;:::-;46079:1:::1;46062:7;:14;;;;:18;46054:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;46159:13;46249:7;:14;;;;46210:15;46227:16;46193:51;;;;;;;;;:::i;:::-;;;;;;;;;;;;;46183:62;;;;;;46175:71;;:88;;;;:::i;:::-;46159:104;;46274:20;46297:16;46307:5;;;;;;;;;;;46297:9;:16::i;:::-;46274:39;;42968:15;46332:12;:31;;46324:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;46418:21;46442:12;46418:36;;46553:7;46561:5;46553:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46544:6;;:23;;;;;;;;;;;;;;;;;;46609:5;46581:33;;:18;:26;46600:6;;;;;;;;;;;46581:26;;;;;;;;;;;;;;;;;;;;;;;;;:33;;::::0;46578:182:::1;;46626:47;46636:5;;;;;;;;;;;46643:7;46651:5;46643:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;46659:13;46626:9;:47::i;:::-;46703:6;;;;;;;;;;;46689:36;;;46711:13;46689:36;;;;;;:::i;:::-;;;;;;;;46578:182;;;46742:16;:14;:16::i;:::-;46578:182;46043:724;;;15774:20:::0;:18;:20::i;:::-;45996:771::o;15810:293::-;15212:1;15944:7;;:19;15936:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;15212:1;16077:7;:18;;;;15810:293::o;16111:213::-;15168:1;16294:7;:22;;;;16111:213::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:99::-;494:6;528:5;522:12;512:22;;442:99;;;:::o;547:169::-;631:11;665:6;660:3;653:19;705:4;700:3;696:14;681:29;;547:169;;;;:::o;722:139::-;811:6;806:3;801;795:23;852:1;843:6;838:3;834:16;827:27;722:139;;;:::o;867:102::-;908:6;959:2;955:7;950:2;943:5;939:14;935:28;925:38;;867:102;;;:::o;975:377::-;1063:3;1091:39;1124:5;1091:39;:::i;:::-;1146:71;1210:6;1205:3;1146:71;:::i;:::-;1139:78;;1226:65;1284:6;1279:3;1272:4;1265:5;1261:16;1226:65;:::i;:::-;1316:29;1338:6;1316:29;:::i;:::-;1311:3;1307:39;1300:46;;1067:285;975:377;;;;:::o;1358:313::-;1471:4;1509:2;1498:9;1494:18;1486:26;;1558:9;1552:4;1548:20;1544:1;1533:9;1529:17;1522:47;1586:78;1659:4;1650:6;1586:78;:::i;:::-;1578:86;;1358:313;;;;:::o;1758:117::-;1867:1;1864;1857:12;2004:126;2041:7;2081:42;2074:5;2070:54;2059:65;;2004:126;;;:::o;2136:96::-;2173:7;2202:24;2220:5;2202:24;:::i;:::-;2191:35;;2136:96;;;:::o;2238:122::-;2311:24;2329:5;2311:24;:::i;:::-;2304:5;2301:35;2291:63;;2350:1;2347;2340:12;2291:63;2238:122;:::o;2366:139::-;2412:5;2450:6;2437:20;2428:29;;2466:33;2493:5;2466:33;:::i;:::-;2366:139;;;;:::o;2511:122::-;2584:24;2602:5;2584:24;:::i;:::-;2577:5;2574:35;2564:63;;2623:1;2620;2613:12;2564:63;2511:122;:::o;2639:139::-;2685:5;2723:6;2710:20;2701:29;;2739:33;2766:5;2739:33;:::i;:::-;2639:139;;;;:::o;2784:474::-;2852:6;2860;2909:2;2897:9;2888:7;2884:23;2880:32;2877:119;;;2915:79;;:::i;:::-;2877:119;3035:1;3060:53;3105:7;3096:6;3085:9;3081:22;3060:53;:::i;:::-;3050:63;;3006:117;3162:2;3188:53;3233:7;3224:6;3213:9;3209:22;3188:53;:::i;:::-;3178:63;;3133:118;2784:474;;;;;:::o;3264:90::-;3298:7;3341:5;3334:13;3327:21;3316:32;;3264:90;;;:::o;3360:109::-;3441:21;3456:5;3441:21;:::i;:::-;3436:3;3429:34;3360:109;;:::o;3475:210::-;3562:4;3600:2;3589:9;3585:18;3577:26;;3613:65;3675:1;3664:9;3660:17;3651:6;3613:65;:::i;:::-;3475:210;;;;:::o;3691:619::-;3768:6;3776;3784;3833:2;3821:9;3812:7;3808:23;3804:32;3801:119;;;3839:79;;:::i;:::-;3801:119;3959:1;3984:53;4029:7;4020:6;4009:9;4005:22;3984:53;:::i;:::-;3974:63;;3930:117;4086:2;4112:53;4157:7;4148:6;4137:9;4133:22;4112:53;:::i;:::-;4102:63;;4057:118;4214:2;4240:53;4285:7;4276:6;4265:9;4261:22;4240:53;:::i;:::-;4230:63;;4185:118;3691:619;;;;;:::o;4316:329::-;4375:6;4424:2;4412:9;4403:7;4399:23;4395:32;4392:119;;;4430:79;;:::i;:::-;4392:119;4550:1;4575:53;4620:7;4611:6;4600:9;4596:22;4575:53;:::i;:::-;4565:63;;4521:117;4316:329;;;;:::o;4651:118::-;4738:24;4756:5;4738:24;:::i;:::-;4733:3;4726:37;4651:118;;:::o;4775:222::-;4868:4;4906:2;4895:9;4891:18;4883:26;;4919:71;4987:1;4976:9;4972:17;4963:6;4919:71;:::i;:::-;4775:222;;;;:::o;5003:86::-;5038:7;5078:4;5071:5;5067:16;5056:27;;5003:86;;;:::o;5095:112::-;5178:22;5194:5;5178:22;:::i;:::-;5173:3;5166:35;5095:112;;:::o;5213:214::-;5302:4;5340:2;5329:9;5325:18;5317:26;;5353:67;5417:1;5406:9;5402:17;5393:6;5353:67;:::i;:::-;5213:214;;;;:::o;5433:329::-;5492:6;5541:2;5529:9;5520:7;5516:23;5512:32;5509:119;;;5547:79;;:::i;:::-;5509:119;5667:1;5692:53;5737:7;5728:6;5717:9;5713:22;5692:53;:::i;:::-;5682:63;;5638:117;5433:329;;;;:::o;5768:116::-;5838:21;5853:5;5838:21;:::i;:::-;5831:5;5828:32;5818:60;;5874:1;5871;5864:12;5818:60;5768:116;:::o;5890:133::-;5933:5;5971:6;5958:20;5949:29;;5987:30;6011:5;5987:30;:::i;:::-;5890:133;;;;:::o;6029:468::-;6094:6;6102;6151:2;6139:9;6130:7;6126:23;6122:32;6119:119;;;6157:79;;:::i;:::-;6119:119;6277:1;6302:53;6347:7;6338:6;6327:9;6323:22;6302:53;:::i;:::-;6292:63;;6248:117;6404:2;6430:50;6472:7;6463:6;6452:9;6448:22;6430:50;:::i;:::-;6420:60;;6375:115;6029:468;;;;;:::o;6503:474::-;6571:6;6579;6628:2;6616:9;6607:7;6603:23;6599:32;6596:119;;;6634:79;;:::i;:::-;6596:119;6754:1;6779:53;6824:7;6815:6;6804:9;6800:22;6779:53;:::i;:::-;6769:63;;6725:117;6881:2;6907:53;6952:7;6943:6;6932:9;6928:22;6907:53;:::i;:::-;6897:63;;6852:118;6503:474;;;;;:::o;6983:180::-;7031:77;7028:1;7021:88;7128:4;7125:1;7118:15;7152:4;7149:1;7142:15;7169:320;7213:6;7250:1;7244:4;7240:12;7230:22;;7297:1;7291:4;7287:12;7318:18;7308:81;;7374:4;7366:6;7362:17;7352:27;;7308:81;7436:2;7428:6;7425:14;7405:18;7402:38;7399:84;;7455:18;;:::i;:::-;7399:84;7220:269;7169:320;;;:::o;7495:224::-;7635:34;7631:1;7623:6;7619:14;7612:58;7704:7;7699:2;7691:6;7687:15;7680:32;7495:224;:::o;7725:366::-;7867:3;7888:67;7952:2;7947:3;7888:67;:::i;:::-;7881:74;;7964:93;8053:3;7964:93;:::i;:::-;8082:2;8077:3;8073:12;8066:19;;7725:366;;;:::o;8097:419::-;8263:4;8301:2;8290:9;8286:18;8278:26;;8350:9;8344:4;8340:20;8336:1;8325:9;8321:17;8314:47;8378:131;8504:4;8378:131;:::i;:::-;8370:139;;8097:419;;;:::o;8522:176::-;8662:28;8658:1;8650:6;8646:14;8639:52;8522:176;:::o;8704:366::-;8846:3;8867:67;8931:2;8926:3;8867:67;:::i;:::-;8860:74;;8943:93;9032:3;8943:93;:::i;:::-;9061:2;9056:3;9052:12;9045:19;;8704:366;;;:::o;9076:419::-;9242:4;9280:2;9269:9;9265:18;9257:26;;9329:9;9323:4;9319:20;9315:1;9304:9;9300:17;9293:47;9357:131;9483:4;9357:131;:::i;:::-;9349:139;;9076:419;;;:::o;9501:442::-;9650:4;9688:2;9677:9;9673:18;9665:26;;9701:71;9769:1;9758:9;9754:17;9745:6;9701:71;:::i;:::-;9782:72;9850:2;9839:9;9835:18;9826:6;9782:72;:::i;:::-;9864;9932:2;9921:9;9917:18;9908:6;9864:72;:::i;:::-;9501:442;;;;;;:::o;9949:179::-;10089:31;10085:1;10077:6;10073:14;10066:55;9949:179;:::o;10134:366::-;10276:3;10297:67;10361:2;10356:3;10297:67;:::i;:::-;10290:74;;10373:93;10462:3;10373:93;:::i;:::-;10491:2;10486:3;10482:12;10475:19;;10134:366;;;:::o;10506:419::-;10672:4;10710:2;10699:9;10695:18;10687:26;;10759:9;10753:4;10749:20;10745:1;10734:9;10730:17;10723:47;10787:131;10913:4;10787:131;:::i;:::-;10779:139;;10506:419;;;:::o;10931:180::-;10979:77;10976:1;10969:88;11076:4;11073:1;11066:15;11100:4;11097:1;11090:15;11117:194;11157:4;11177:20;11195:1;11177:20;:::i;:::-;11172:25;;11211:20;11229:1;11211:20;:::i;:::-;11206:25;;11255:1;11252;11248:9;11240:17;;11279:1;11273:4;11270:11;11267:37;;;11284:18;;:::i;:::-;11267:37;11117:194;;;;:::o;11317:180::-;11365:77;11362:1;11355:88;11462:4;11459:1;11452:15;11486:4;11483:1;11476:15;11503:180;11551:77;11548:1;11541:88;11648:4;11645:1;11638:15;11672:4;11669:1;11662:15;11689:191;11729:3;11748:20;11766:1;11748:20;:::i;:::-;11743:25;;11782:20;11800:1;11782:20;:::i;:::-;11777:25;;11825:1;11822;11818:9;11811:16;;11846:3;11843:1;11840:10;11837:36;;;11853:18;;:::i;:::-;11837:36;11689:191;;;;:::o;11886:410::-;11926:7;11949:20;11967:1;11949:20;:::i;:::-;11944:25;;11983:20;12001:1;11983:20;:::i;:::-;11978:25;;12038:1;12035;12031:9;12060:30;12078:11;12060:30;:::i;:::-;12049:41;;12239:1;12230:7;12226:15;12223:1;12220:22;12200:1;12193:9;12173:83;12150:139;;12269:18;;:::i;:::-;12150:139;11934:362;11886:410;;;;:::o;12302:180::-;12350:77;12347:1;12340:88;12447:4;12444:1;12437:15;12471:4;12468:1;12461:15;12488:185;12528:1;12545:20;12563:1;12545:20;:::i;:::-;12540:25;;12579:20;12597:1;12579:20;:::i;:::-;12574:25;;12618:1;12608:35;;12623:18;;:::i;:::-;12608:35;12665:1;12662;12658:9;12653:14;;12488:185;;;;:::o;12679:179::-;12819:31;12815:1;12807:6;12803:14;12796:55;12679:179;:::o;12864:366::-;13006:3;13027:67;13091:2;13086:3;13027:67;:::i;:::-;13020:74;;13103:93;13192:3;13103:93;:::i;:::-;13221:2;13216:3;13212:12;13205:19;;12864:366;;;:::o;13236:419::-;13402:4;13440:2;13429:9;13425:18;13417:26;;13489:9;13483:4;13479:20;13475:1;13464:9;13460:17;13453:47;13517:131;13643:4;13517:131;:::i;:::-;13509:139;;13236:419;;;:::o;13661:79::-;13700:7;13729:5;13718:16;;13661:79;;;:::o;13746:157::-;13851:45;13871:24;13889:5;13871:24;:::i;:::-;13851:45;:::i;:::-;13846:3;13839:58;13746:157;;:::o;13909:397::-;14049:3;14064:75;14135:3;14126:6;14064:75;:::i;:::-;14164:2;14159:3;14155:12;14148:19;;14177:75;14248:3;14239:6;14177:75;:::i;:::-;14277:2;14272:3;14268:12;14261:19;;14297:3;14290:10;;13909:397;;;;;:::o;14312:176::-;14344:1;14361:20;14379:1;14361:20;:::i;:::-;14356:25;;14395:20;14413:1;14395:20;:::i;:::-;14390:25;;14434:1;14424:35;;14439:18;;:::i;:::-;14424:35;14480:1;14477;14473:9;14468:14;;14312:176;;;;:::o;14494:226::-;14634:34;14630:1;14622:6;14618:14;14611:58;14703:9;14698:2;14690:6;14686:15;14679:34;14494:226;:::o;14726:366::-;14868:3;14889:67;14953:2;14948:3;14889:67;:::i;:::-;14882:74;;14965:93;15054:3;14965:93;:::i;:::-;15083:2;15078:3;15074:12;15067:19;;14726:366;;;:::o;15098:419::-;15264:4;15302:2;15291:9;15287:18;15279:26;;15351:9;15345:4;15341:20;15337:1;15326:9;15322:17;15315:47;15379:131;15505:4;15379:131;:::i;:::-;15371:139;;15098:419;;;:::o;15523:181::-;15663:33;15659:1;15651:6;15647:14;15640:57;15523:181;:::o;15710:366::-;15852:3;15873:67;15937:2;15932:3;15873:67;:::i;:::-;15866:74;;15949:93;16038:3;15949:93;:::i;:::-;16067:2;16062:3;16058:12;16051:19;;15710:366;;;:::o;16082:419::-;16248:4;16286:2;16275:9;16271:18;16263:26;;16335:9;16329:4;16325:20;16321:1;16310:9;16306:17;16299:47;16363:131;16489:4;16363:131;:::i;:::-;16355:139;;16082:419;;;:::o

ipfs://81ad0d9d6074226f9db8bd33d185f18cae6ea4d21f8d02ab7acb536e34588a9b