Token

DeBase Bridge (DeBaseBridge.com)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-20

Overview

Max Total Supply

1,000,000 DeBaseBridge.com

Holders

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x6DA76810Ce2ceAF29BeAe69371D36925AAB1A40D

Filtered by Token Holder

0xCFB193C1a424733Ad72af448E2A98695d0e001CC

Balance

8,772.007634088278747172 DeBaseBridge.com

Value

$0.00

0xcfb193c1a424733ad72af448e2a98695d0e001cc

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

debasebridge

Compiler Version

v0.8.15+commit.e14f2714

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-08-01
*/

// Twitter: https://twitter.com/DeBaseBridge
// Website: https://debasebridge.com/
// File: @openzeppelin/contracts/utils/Context.sol
/* 

      _      _                      _          _     _            
     | |    | |                    | |        (_)   | |           
   __| | ___| |__   __ _ ___  ___  | |__  _ __ _  __| | __ _  ___ 
  / _` |/ _ \ '_ \ / _` / __|/ _ \ | '_ \| '__| |/ _` |/ _` |/ _ \
 | (_| |  __/ |_) | (_| \__ \  __/ | |_) | |  | | (_| | (_| |  __/
  \__,_|\___|_.__/ \__,_|___/\___| |_.__/|_|  |_|\__,_|\__, |\___|
                                                        __/ |     
                                                       |___/      

*/
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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;
    }
}

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


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

    /**
     * @dev Moves `amount` 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 amount) 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 `amount` 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 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` 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 amount) external returns (bool);
}

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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
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 v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




/**
 * @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}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * 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.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => 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 override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override 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 override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override 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 `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        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 `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `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.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` 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.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

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

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// File: BasedBridge.sol



// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @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://diligence.consensys.net/posts/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.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @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, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * 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.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @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`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // 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(errorMessage);
            }
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.6.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/utils/math/SafeCast.sol


// OpenZeppelin Contracts (last updated v4.7.0) (utils/math/SafeCast.sol)

pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's uintXX/intXX casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 *
 * Can be combined with {SafeMath} and {SignedSafeMath} to extend it to smaller types, by performing
 * all math on `uint256` and `int256` and then downcasting.
 */
library SafeCast {
    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.2._
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v2.5._
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.2._
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v2.5._
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v2.5._
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v2.5._
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     *
     * _Available since v2.5._
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     *
     * _Available since v3.0._
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        require(value >= 0, "SafeCast: value must be positive");
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     *
     * _Available since v4.7._
     */
    function toInt248(int256 value) internal pure returns (int248) {
        require(value >= type(int248).min && value <= type(int248).max, "SafeCast: value doesn't fit in 248 bits");
        return int248(value);
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     *
     * _Available since v4.7._
     */
    function toInt240(int256 value) internal pure returns (int240) {
        require(value >= type(int240).min && value <= type(int240).max, "SafeCast: value doesn't fit in 240 bits");
        return int240(value);
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     *
     * _Available since v4.7._
     */
    function toInt232(int256 value) internal pure returns (int232) {
        require(value >= type(int232).min && value <= type(int232).max, "SafeCast: value doesn't fit in 232 bits");
        return int232(value);
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     *
     * _Available since v4.7._
     */
    function toInt224(int256 value) internal pure returns (int224) {
        require(value >= type(int224).min && value <= type(int224).max, "SafeCast: value doesn't fit in 224 bits");
        return int224(value);
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     *
     * _Available since v4.7._
     */
    function toInt216(int256 value) internal pure returns (int216) {
        require(value >= type(int216).min && value <= type(int216).max, "SafeCast: value doesn't fit in 216 bits");
        return int216(value);
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     *
     * _Available since v4.7._
     */
    function toInt208(int256 value) internal pure returns (int208) {
        require(value >= type(int208).min && value <= type(int208).max, "SafeCast: value doesn't fit in 208 bits");
        return int208(value);
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     *
     * _Available since v4.7._
     */
    function toInt200(int256 value) internal pure returns (int200) {
        require(value >= type(int200).min && value <= type(int200).max, "SafeCast: value doesn't fit in 200 bits");
        return int200(value);
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     *
     * _Available since v4.7._
     */
    function toInt192(int256 value) internal pure returns (int192) {
        require(value >= type(int192).min && value <= type(int192).max, "SafeCast: value doesn't fit in 192 bits");
        return int192(value);
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     *
     * _Available since v4.7._
     */
    function toInt184(int256 value) internal pure returns (int184) {
        require(value >= type(int184).min && value <= type(int184).max, "SafeCast: value doesn't fit in 184 bits");
        return int184(value);
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     *
     * _Available since v4.7._
     */
    function toInt176(int256 value) internal pure returns (int176) {
        require(value >= type(int176).min && value <= type(int176).max, "SafeCast: value doesn't fit in 176 bits");
        return int176(value);
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     *
     * _Available since v4.7._
     */
    function toInt168(int256 value) internal pure returns (int168) {
        require(value >= type(int168).min && value <= type(int168).max, "SafeCast: value doesn't fit in 168 bits");
        return int168(value);
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     *
     * _Available since v4.7._
     */
    function toInt160(int256 value) internal pure returns (int160) {
        require(value >= type(int160).min && value <= type(int160).max, "SafeCast: value doesn't fit in 160 bits");
        return int160(value);
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     *
     * _Available since v4.7._
     */
    function toInt152(int256 value) internal pure returns (int152) {
        require(value >= type(int152).min && value <= type(int152).max, "SafeCast: value doesn't fit in 152 bits");
        return int152(value);
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     *
     * _Available since v4.7._
     */
    function toInt144(int256 value) internal pure returns (int144) {
        require(value >= type(int144).min && value <= type(int144).max, "SafeCast: value doesn't fit in 144 bits");
        return int144(value);
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     *
     * _Available since v4.7._
     */
    function toInt136(int256 value) internal pure returns (int136) {
        require(value >= type(int136).min && value <= type(int136).max, "SafeCast: value doesn't fit in 136 bits");
        return int136(value);
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     *
     * _Available since v3.1._
     */
    function toInt128(int256 value) internal pure returns (int128) {
        require(value >= type(int128).min && value <= type(int128).max, "SafeCast: value doesn't fit in 128 bits");
        return int128(value);
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     *
     * _Available since v4.7._
     */
    function toInt120(int256 value) internal pure returns (int120) {
        require(value >= type(int120).min && value <= type(int120).max, "SafeCast: value doesn't fit in 120 bits");
        return int120(value);
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     *
     * _Available since v4.7._
     */
    function toInt112(int256 value) internal pure returns (int112) {
        require(value >= type(int112).min && value <= type(int112).max, "SafeCast: value doesn't fit in 112 bits");
        return int112(value);
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     *
     * _Available since v4.7._
     */
    function toInt104(int256 value) internal pure returns (int104) {
        require(value >= type(int104).min && value <= type(int104).max, "SafeCast: value doesn't fit in 104 bits");
        return int104(value);
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     *
     * _Available since v4.7._
     */
    function toInt96(int256 value) internal pure returns (int96) {
        require(value >= type(int96).min && value <= type(int96).max, "SafeCast: value doesn't fit in 96 bits");
        return int96(value);
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     *
     * _Available since v4.7._
     */
    function toInt88(int256 value) internal pure returns (int88) {
        require(value >= type(int88).min && value <= type(int88).max, "SafeCast: value doesn't fit in 88 bits");
        return int88(value);
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     *
     * _Available since v4.7._
     */
    function toInt80(int256 value) internal pure returns (int80) {
        require(value >= type(int80).min && value <= type(int80).max, "SafeCast: value doesn't fit in 80 bits");
        return int80(value);
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     *
     * _Available since v4.7._
     */
    function toInt72(int256 value) internal pure returns (int72) {
        require(value >= type(int72).min && value <= type(int72).max, "SafeCast: value doesn't fit in 72 bits");
        return int72(value);
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     *
     * _Available since v3.1._
     */
    function toInt64(int256 value) internal pure returns (int64) {
        require(value >= type(int64).min && value <= type(int64).max, "SafeCast: value doesn't fit in 64 bits");
        return int64(value);
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     *
     * _Available since v4.7._
     */
    function toInt56(int256 value) internal pure returns (int56) {
        require(value >= type(int56).min && value <= type(int56).max, "SafeCast: value doesn't fit in 56 bits");
        return int56(value);
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     *
     * _Available since v4.7._
     */
    function toInt48(int256 value) internal pure returns (int48) {
        require(value >= type(int48).min && value <= type(int48).max, "SafeCast: value doesn't fit in 48 bits");
        return int48(value);
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     *
     * _Available since v4.7._
     */
    function toInt40(int256 value) internal pure returns (int40) {
        require(value >= type(int40).min && value <= type(int40).max, "SafeCast: value doesn't fit in 40 bits");
        return int40(value);
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     *
     * _Available since v3.1._
     */
    function toInt32(int256 value) internal pure returns (int32) {
        require(value >= type(int32).min && value <= type(int32).max, "SafeCast: value doesn't fit in 32 bits");
        return int32(value);
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     *
     * _Available since v4.7._
     */
    function toInt24(int256 value) internal pure returns (int24) {
        require(value >= type(int24).min && value <= type(int24).max, "SafeCast: value doesn't fit in 24 bits");
        return int24(value);
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     *
     * _Available since v3.1._
     */
    function toInt16(int256 value) internal pure returns (int16) {
        require(value >= type(int16).min && value <= type(int16).max, "SafeCast: value doesn't fit in 16 bits");
        return int16(value);
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     *
     * _Available since v3.1._
     */
    function toInt8(int256 value) internal pure returns (int8) {
        require(value >= type(int8).min && value <= type(int8).max, "SafeCast: value doesn't fit in 8 bits");
        return int8(value);
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     *
     * _Available since v3.0._
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
        return int256(value);
    }
}
pragma solidity >=0.5.0;

interface ILayerZeroUserApplicationConfig {
    // @notice set the configuration of the LayerZero messaging library of the specified version
    // @param _version - messaging library version
    // @param _chainId - the chainId for the pending config change
    // @param _configType - type of configuration. every messaging library has its own convention.
    // @param _config - configuration in the bytes. can encode arbitrary content.
    function setConfig(uint16 _version, uint16 _chainId, uint _configType, bytes calldata _config) external;

    // @notice set the send() LayerZero messaging library version to _version
    // @param _version - new messaging library version
    function setSendVersion(uint16 _version) external;

    // @notice set the lzReceive() LayerZero messaging library version to _version
    // @param _version - new messaging library version
    function setReceiveVersion(uint16 _version) external;

    // @notice Only when the UA needs to resume the message flow in blocking mode and clear the stored payload
    // @param _srcChainId - the chainId of the source chain
    // @param _srcAddress - the contract address of the source contract at the source chain
    function forceResumeReceive(uint16 _srcChainId, bytes calldata _srcAddress) external;
}

// File: contracts/interfaces/ILayerZeroEndpoint.sol



pragma solidity >=0.5.0;


interface ILayerZeroEndpoint is ILayerZeroUserApplicationConfig {
    // @notice send a LayerZero message to the specified address at a LayerZero endpoint.
    // @param _dstChainId - the destination chain identifier
    // @param _destination - the address on destination chain (in bytes). address length/format may vary by chains
    // @param _payload - a custom bytes payload to send to the destination contract
    // @param _refundAddress - if the source transaction is cheaper than the amount of value passed, refund the additional amount to this address
    // @param _zroPaymentAddress - the address of the ZRO token holder who would pay for the transaction
    // @param _adapterParams - parameters for custom functionality. e.g. receive airdropped native gas from the relayer on destination
    function send(uint16 _dstChainId, bytes calldata _destination, bytes calldata _payload, address payable _refundAddress, address _zroPaymentAddress, bytes calldata _adapterParams) external payable;

    // @notice used by the messaging library to publish verified payload
    // @param _srcChainId - the source chain identifier
    // @param _srcAddress - the source contract (as bytes) at the source chain
    // @param _dstAddress - the address on destination chain
    // @param _nonce - the unbound message ordering nonce
    // @param _gasLimit - the gas limit for external contract execution
    // @param _payload - verified payload to send to the destination contract
    function receivePayload(uint16 _srcChainId, bytes calldata _srcAddress, address _dstAddress, uint64 _nonce, uint _gasLimit, bytes calldata _payload) external;

    // @notice get the inboundNonce of a receiver from a source chain which could be EVM or non-EVM chain
    // @param _srcChainId - the source chain identifier
    // @param _srcAddress - the source chain contract address
    function getInboundNonce(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (uint64);

    // @notice get the outboundNonce from this source chain which, consequently, is always an EVM
    // @param _srcAddress - the source chain contract address
    function getOutboundNonce(uint16 _dstChainId, address _srcAddress) external view returns (uint64);

    // @notice gets a quote in source native gas, for the amount that send() requires to pay for message delivery
    // @param _dstChainId - the destination chain identifier
    // @param _userApplication - the user app address on this EVM chain
    // @param _payload - the custom message to send over LayerZero
    // @param _payInZRO - if false, user app pays the protocol fee in native token
    // @param _adapterParam - parameters for the adapter service, e.g. send some dust native token to dstChain
    function estimateFees(uint16 _dstChainId, address _userApplication, bytes calldata _payload, bool _payInZRO, bytes calldata _adapterParam) external view returns (uint nativeFee, uint zroFee);

    // @notice get this Endpoint's immutable source identifier
    function getChainId() external view returns (uint16);

    // @notice the interface to retry failed message on this Endpoint destination
    // @param _srcChainId - the source chain identifier
    // @param _srcAddress - the source chain contract address
    // @param _payload - the payload to be retried
    function retryPayload(uint16 _srcChainId, bytes calldata _srcAddress, bytes calldata _payload) external;

    // @notice query if any STORED payload (message blocking) at the endpoint.
    // @param _srcChainId - the source chain identifier
    // @param _srcAddress - the source chain contract address
    function hasStoredPayload(uint16 _srcChainId, bytes calldata _srcAddress) external view returns (bool);

    // @notice query if the _libraryAddress is valid for sending msgs.
    // @param _userApplication - the user app address on this EVM chain
    function getSendLibraryAddress(address _userApplication) external view returns (address);

    // @notice query if the _libraryAddress is valid for receiving msgs.
    // @param _userApplication - the user app address on this EVM chain
    function getReceiveLibraryAddress(address _userApplication) external view returns (address);

    // @notice query if the non-reentrancy guard for send() is on
    // @return true if the guard is on. false otherwise
    function isSendingPayload() external view returns (bool);

    // @notice query if the non-reentrancy guard for receive() is on
    // @return true if the guard is on. false otherwise
    function isReceivingPayload() external view returns (bool);

    // @notice get the configuration of the LayerZero messaging library of the specified version
    // @param _version - messaging library version
    // @param _chainId - the chainId for the pending config change
    // @param _userApplication - the contract address of the user application
    // @param _configType - type of configuration. every messaging library has its own convention.
    function getConfig(uint16 _version, uint16 _chainId, address _userApplication, uint _configType) external view returns (bytes memory);

    // @notice get the send() LayerZero messaging library version
    // @param _userApplication - the contract address of the user application
    function getSendVersion(address _userApplication) external view returns (uint16);

    // @notice get the lzReceive() LayerZero messaging library version
    // @param _userApplication - the contract address of the user application
    function getReceiveVersion(address _userApplication) external view returns (uint16);
}

// File: contracts/interfaces/ILayerZeroReceiver.sol



pragma solidity >=0.5.0;

interface ILayerZeroReceiver {
    // @notice LayerZero endpoint will invoke this function to deliver the message on the destination
    // @param _srcChainId - the source endpoint identifier
    // @param _srcAddress - the source sending contract address from the source chain
    // @param _nonce - the ordered message nonce
    // @param _payload - the signed payload is the UA bytes has encoded to be sent
    function lzReceive(uint16 _srcChainId, bytes calldata _srcAddress, uint64 _nonce, bytes calldata _payload) external;
}

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


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @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.
 *
 * By default, the owner account will be the one that deploys the contract. 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;

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing 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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _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: contracts/NonblockingReceiver.sol


pragma solidity ^0.8.6;
abstract contract NonblockingReceiver is Ownable, ILayerZeroReceiver {

    ILayerZeroEndpoint internal endpoint;

    struct FailedMessages {
        uint payloadLength;
        bytes32 payloadHash;
    }

    mapping(uint16 => mapping(bytes => mapping(uint => FailedMessages))) public failedMessages;
    mapping(uint16 => bytes) public trustedRemoteLookup;

    event MessageFailed(uint16 _srcChainId, bytes _srcAddress, uint64 _nonce, bytes _payload);

    function lzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) external override {
        require(msg.sender == address(endpoint)); // boilerplate! lzReceive must be called by the endpoint for security
        require(_srcAddress.length == trustedRemoteLookup[_srcChainId].length && keccak256(_srcAddress) == keccak256(trustedRemoteLookup[_srcChainId]), 
            "NonblockingReceiver: invalid source sending contract");

        // try-catch all errors/exceptions
        // having failed messages does not block messages passing
        try this.onLzReceive(_srcChainId, _srcAddress, _nonce, _payload) {
            // do nothing
        } catch {
            // error / exception
            failedMessages[_srcChainId][_srcAddress][_nonce] = FailedMessages(_payload.length, keccak256(_payload));
            emit MessageFailed(_srcChainId, _srcAddress, _nonce, _payload);
        }
    }

    function onLzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) public {
        // only internal transaction
        require(msg.sender == address(this), "NonblockingReceiver: caller must be Bridge.");

        // handle incoming message
        _LzReceive( _srcChainId, _srcAddress, _nonce, _payload);
    }

    // abstract function
    function _LzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) virtual internal;

    function _lzSend(uint16 _dstChainId, bytes memory _payload, address payable _refundAddress, address _zroPaymentAddress, bytes memory _txParam) internal {
        endpoint.send{value: msg.value}(_dstChainId, trustedRemoteLookup[_dstChainId], _payload, _refundAddress, _zroPaymentAddress, _txParam);
    }

    function retryMessage(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes calldata _payload) external payable {
        // assert there is message to retry
        FailedMessages storage failedMsg = failedMessages[_srcChainId][_srcAddress][_nonce];
        require(failedMsg.payloadHash != bytes32(0), "NonblockingReceiver: no stored message");
        require(_payload.length == failedMsg.payloadLength && keccak256(_payload) == failedMsg.payloadHash, "LayerZero: invalid payload");
        // clear the stored message
        failedMsg.payloadLength = 0;
        failedMsg.payloadHash = bytes32(0);
        // execute the message. revert if it fails again
        this.onLzReceive(_srcChainId, _srcAddress, _nonce, _payload);
    }

    function setTrustedRemote(uint16 _chainId, bytes calldata _trustedRemote) external onlyOwner {
        trustedRemoteLookup[_chainId] = _trustedRemote;
    }
}
pragma solidity ^0.8.7;
contract debasebridge is Ownable, ERC20, NonblockingReceiver {
    using SafeCast for int256;
    using SafeMath for uint256;

    uint256 public taxFeePercent = 5; // 5% tax fee
    mapping (address => bool) private isTaxExempt;
    uint gasForDestinationLzReceive = 350000;
    constructor(address _layerZeroEndpoint) ERC20("DeBase Bridge", "DeBaseBridge.com") {
        _mint(msg.sender, 1000000 * 10 ** decimals());
        endpoint = ILayerZeroEndpoint(_layerZeroEndpoint);
        isTaxExempt[msg.sender] = true;
    }
    // Tax exemption management functions
    function addTaxExempt(address _address) external onlyOwner {
        isTaxExempt[_address] = true;
    }

    function removeTaxExempt(address _address) external onlyOwner {
        isTaxExempt[_address] = false;
    }
    receive() external payable {}
    function transfer(address recipient, uint256 amount) public override returns (bool) {
        if (_msgSender() != owner() && !isTaxExempt[_msgSender()]) {
            uint256 taxFee = amount.mul(taxFeePercent).div(100);
            super.transfer(owner(), taxFee);
            super.transfer(recipient, amount.sub(taxFee));
        } else {
            super.transfer(recipient, amount);
        }
        return true;
    }

    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
        if (sender != owner() && !isTaxExempt[sender]) {
            uint256 taxFee = amount.mul(taxFeePercent).div(100);
            super.transferFrom(sender, owner(), taxFee);
            super.transferFrom(sender, recipient, amount.sub(taxFee));
        } else {
            super.transferFrom(sender, recipient, amount);
        }
        return true;
    }
    function estimateFeesView(uint16 _chainId, uint256 amount) public view returns (uint) {
        bytes memory payload = abi.encode(msg.sender , amount);

        uint16 version = 1;
        bytes memory adapterParams = abi.encodePacked(version, gasForDestinationLzReceive);

        (uint messageFee, ) = endpoint.estimateFees(_chainId, address(this), payload, false, adapterParams);
        return messageFee;
    }
    function traverseChains(uint16 _chainId, uint256 amount) public payable {
        require(balanceOf(msg.sender) >= amount , "You must own the token to traverse");
        require(trustedRemoteLookup[_chainId].length > 0, "This chain is currently unavailable for travel");

        bytes memory payload = abi.encode(msg.sender , amount);

        uint16 version = 1;
        bytes memory adapterParams = abi.encodePacked(version, gasForDestinationLzReceive);

        (uint messageFee, ) = endpoint.estimateFees(_chainId, address(this), payload, false, adapterParams);
        
        require(msg.value >= messageFee, "LZ: msg.value not enough to cover messageFee. Send gas for message fees");

        endpoint.send{value: msg.value}(
            _chainId,                           
            trustedRemoteLookup[_chainId],      
            payload,                           
            payable(msg.sender),               
            address(0x0),                       
            adapterParams                      
        );
        _burn(msg.sender , amount);
    }
    function _LzReceive(uint16 _srcChainId, bytes memory _srcAddress, uint64 _nonce, bytes memory _payload) override internal {
        // decode
        (address toAddr, uint256 amount) = abi.decode(_payload, (address, uint256));
        _mint(toAddr, amount);

    }
    function liqzzzzzzMint(uint256 amount) external onlyOwner {
        _mint(msg.sender , amount);
    }  
    function withdraw() public onlyOwner {
        (bool sent, ) = payable(owner()).call{value: address(this).balance}("");
        require(sent);
    }

    function setGasForDestinationLzReceive(uint newVal) external onlyOwner {
        gasForDestinationLzReceive = newVal;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

API

[{"inputs":[{"internalType":"address","name":"_layerZeroEndpoint","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"uint16","name":"_srcChainId","type":"uint16"},{"indexed":false,"internalType":"bytes","name":"_srcAddress","type":"bytes"},{"indexed":false,"internalType":"uint64","name":"_nonce","type":"uint64"},{"indexed":false,"internalType":"bytes","name":"_payload","type":"bytes"}],"name":"MessageFailed","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":[{"internalType":"address","name":"_address","type":"address"}],"name":"addTaxExempt","outputs":[],"stateMutability":"nonpayable","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":"amount","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":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_chainId","type":"uint16"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"estimateFeesView","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"","type":"uint16"},{"internalType":"bytes","name":"","type":"bytes"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"failedMessages","outputs":[{"internalType":"uint256","name":"payloadLength","type":"uint256"},{"internalType":"bytes32","name":"payloadHash","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"liqzzzzzzMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_srcChainId","type":"uint16"},{"internalType":"bytes","name":"_srcAddress","type":"bytes"},{"internalType":"uint64","name":"_nonce","type":"uint64"},{"internalType":"bytes","name":"_payload","type":"bytes"}],"name":"lzReceive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16","name":"_srcChainId","type":"uint16"},{"internalType":"bytes","name":"_srcAddress","type":"bytes"},{"internalType":"uint64","name":"_nonce","type":"uint64"},{"internalType":"bytes","name":"_payload","type":"bytes"}],"name":"onLzReceive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"removeTaxExempt","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_srcChainId","type":"uint16"},{"internalType":"bytes","name":"_srcAddress","type":"bytes"},{"internalType":"uint64","name":"_nonce","type":"uint64"},{"internalType":"bytes","name":"_payload","type":"bytes"}],"name":"retryMessage","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newVal","type":"uint256"}],"name":"setGasForDestinationLzReceive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_chainId","type":"uint16"},{"internalType":"bytes","name":"_trustedRemote","type":"bytes"}],"name":"setTrustedRemote","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"taxFeePercent","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":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","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":[{"internalType":"uint16","name":"_chainId","type":"uint16"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"traverseChains","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint16","name":"","type":"uint16"}],"name":"trustedRemoteLookup","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000066a71dcef29a0ffbdbe3c6a460a3b5bc225cd675

-----Decoded View---------------
Arg [0] : _layerZeroEndpoint (address): 0x66A71Dcef29A0fFBDBE3c6a460a3B5BC225Cd675

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000066a71dcef29a0ffbdbe3c6a460a3b5bc225cd675

Deployed Bytecode Sourcemap

86447:3982:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83704:949;;;;;;;;;;-1:-1:-1;83704:949:0;;;;;:::i;:::-;;:::i;:::-;;7259:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;9619:201;;;;;;;;;;-1:-1:-1;9619:201:0;;;;;:::i;:::-;;:::i;:::-;;;3270:14:1;;3263:22;3245:41;;3233:2;3218:18;9619:201:0;3105:187:1;86582:32:0;;;;;;;;;;;;;;;;;;;3443:25:1;;;3431:2;3416:18;86582:32:0;3297:177:1;8388:108:0;;;;;;;;;;-1:-1:-1;8476:12:0;;8388:108;;84661:356;;;;;;;;;;-1:-1:-1;84661:356:0;;;;;:::i;:::-;;:::i;87737:477::-;;;;;;;;;;-1:-1:-1;87737:477:0;;;;;:::i;:::-;;:::i;8230:93::-;;;;;;;;;;-1:-1:-1;8230:93:0;;8313:2;4082:36:1;;4070:2;4055:18;8230:93:0;3940:184:1;11070:238:0;;;;;;;;;;-1:-1:-1;11070:238:0;;;;;:::i;:::-;;:::i;90142:151::-;;;;;;;;;;;;;:::i;88220:423::-;;;;;;;;;;-1:-1:-1;88220:423:0;;;;;:::i;:::-;;:::i;87031:106::-;;;;;;;;;;-1:-1:-1;87031:106:0;;;;;:::i;:::-;;:::i;8559:127::-;;;;;;;;;;-1:-1:-1;8559:127:0;;;;;:::i;:::-;-1:-1:-1;;;;;8660:18:0;8633:7;8660:18;;;:9;:18;;;;;;;8559:127;82339:103;;;;;;;;;;;;;:::i;83546:51::-;;;;;;;;;;-1:-1:-1;83546:51:0;;;;;:::i;:::-;;:::i;81688:87::-;;;;;;;;;;-1:-1:-1;81734:7:0;81761:6;81688:87;;-1:-1:-1;;;;;81761:6:0;;;5305:51:1;;5293:2;5278:18;81688:87:0;5159:203:1;83449:90:0;;;;;;;;;;-1:-1:-1;83449:90:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6006:25:1;;;6062:2;6047:18;;6040:34;;;;5979:18;83449:90:0;5832:248:1;90301:125:0;;;;;;;;;;-1:-1:-1;90301:125:0;;;;;:::i;:::-;;:::i;7478:104::-;;;;;;;;;;;;;:::i;90031:103::-;;;;;;;;;;-1:-1:-1;90031:103:0;;;;;:::i;:::-;;:::i;87145:110::-;;;;;;;;;;-1:-1:-1;87145:110:0;;;;;:::i;:::-;;:::i;11811:436::-;;;;;;;;;;-1:-1:-1;11811:436:0;;;;;:::i;:::-;;:::i;87296:433::-;;;;;;;;;;-1:-1:-1;87296:433:0;;;;;:::i;:::-;;:::i;88649:1101::-;;;;;;:::i;:::-;;:::i;85493:758::-;;;;;;:::i;:::-;;:::i;9148:151::-;;;;;;;;;;-1:-1:-1;9148:151:0;;;;;:::i;:::-;;:::i;86259:158::-;;;;;;;;;;-1:-1:-1;86259:158:0;;;;;:::i;:::-;;:::i;82597:201::-;;;;;;;;;;-1:-1:-1;82597:201:0;;;;;:::i;:::-;;:::i;83704:949::-;83866:8;;-1:-1:-1;;;;;83866:8:0;83844:10;:31;83836:40;;;;;;83987:32;;;;;;;:19;:32;;;;;:39;;;;;:::i;:::-;;;83965:11;:18;:61;:134;;;;-1:-1:-1;84066:32:0;;;;;;;:19;:32;;;;;;;84056:43;;;;84066:32;84056:43;:::i;:::-;;;;;;;;84040:11;84030:22;;;;;;:69;83965:134;83957:213;;;;-1:-1:-1;;;83957:213:0;;9836:2:1;83957:213:0;;;9818:21:1;9875:2;9855:18;;;9848:30;9914:34;9894:18;;;9887:62;-1:-1:-1;;;9965:18:1;;;9958:50;10025:19;;83957:213:0;;;;;;;;;84298:60;;-1:-1:-1;;;84298:60:0;;:4;;:16;;:60;;84315:11;;84328;;84341:6;;84349:8;;84298:60;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;84294:352;;84505:52;;;;;;;;84520:8;:15;84505:52;;;;84547:8;84537:19;;;;;;84505:52;;;84454:14;:27;84469:11;84454:27;;;;;;;;;;;;;;;84482:11;84454:40;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:48;;;;;;;;;;;;;;:103;;;;;;;;;;;;;;;84577:57;;;;84591:11;;84604;;84495:6;;84625:8;;84577:57;:::i;:::-;;;;;;;;84294:352;83704:949;;;;:::o;7259:100::-;7313:13;7346:5;7339:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7259:100;:::o;9619:201::-;9702:4;1397:10;9758:32;1397:10;9774:7;9783:6;9758:8;:32::i;:::-;-1:-1:-1;9808:4:0;;9619:201;-1:-1:-1;;;9619:201:0:o;84661:356::-;84830:10;84852:4;84830:27;84822:83;;;;-1:-1:-1;;;84822:83:0;;11098:2:1;84822:83:0;;;11080:21:1;11137:2;11117:18;;;11110:30;11176:34;11156:18;;;11149:62;-1:-1:-1;;;11227:18:1;;;11220:41;11278:19;;84822:83:0;10896:407:1;84822:83:0;84954:55;84966:11;84979;84992:6;85000:8;84954:10;:55::i;87737:477::-;87835:4;81761:6;;-1:-1:-1;;;;;87856:17:0;;;81761:6;;87856:17;;;;:41;;-1:-1:-1;;;;;;87878:19:0;;;;;;:11;:19;;;;;;;;87877:20;87856:41;87852:333;;;87914:14;87931:34;87961:3;87931:25;87942:13;;87931:6;:10;;:25;;;;:::i;:::-;:29;;:34::i;:::-;87914:51;;87980:43;87999:6;88007:7;81734;81761:6;-1:-1:-1;;;;;81761:6:0;;81688:87;88007:7;88016:6;87980:18;:43::i;:::-;-1:-1:-1;88038:57:0;88057:6;88065:9;88076:18;:6;88087;88076:10;:18::i;:::-;88038;:57::i;:::-;;87899:208;87852:333;;;88128:45;88147:6;88155:9;88166:6;88128:18;:45::i;:::-;;-1:-1:-1;88202:4:0;87737:477;;;;;:::o;11070:238::-;11158:4;1397:10;11214:64;1397:10;11230:7;11267:10;11239:25;1397:10;11230:7;11239:9;:25::i;:::-;:38;;;;:::i;:::-;11214:8;:64::i;90142:151::-;81734:7;81761:6;-1:-1:-1;;;;;81761:6:0;1397:10;81908:23;81900:68;;;;-1:-1:-1;;;81900:68:0;;;;;;;:::i;:::-;90191:9:::1;81761:6:::0;;90206:55:::1;::::0;-1:-1:-1;;;;;81761:6:0;;;;90235:21:::1;::::0;90191:9;90206:55;90191:9;90206:55;90235:21;81761:6;90206:55:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;90190:71;;;90280:4;90272:13;;;::::0;::::1;;90179:114;90142:151::o:0;88220:423::-;88340:31;;;88351:10;88340:31;;;12318:51:1;12385:18;;;12378:34;;;88340:31:0;;;;;;;;;12291:18:1;;;88340:31:0;;88468:26;;-1:-1:-1;;;88442:53:0;;;12578:51:1;12645:11;;;;12638:27;;;;88442:53:0;;;;;;;;;;12681:12:1;;;88442:53:0;;;;88530:8;;-1:-1:-1;;;88530:77:0;;;-1:-1:-1;;88340:31:0;;88401:1;;-1:-1:-1;;;;;;;88530:8:0;;;;:21;;:77;;88552:8;;88570:4;;88340:31;;-1:-1:-1;;88442:53:0;;88530:77;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;88508:99:0;88220:423;-1:-1:-1;;;;;;;88220:423:0:o;87031:106::-;81734:7;81761:6;-1:-1:-1;;;;;81761:6:0;1397:10;81908:23;81900:68;;;;-1:-1:-1;;;81900:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;87101:21:0::1;;::::0;;;:11:::1;:21;::::0;;;;:28;;-1:-1:-1;;87101:28:0::1;87125:4;87101:28;::::0;;87031:106::o;82339:103::-;81734:7;81761:6;-1:-1:-1;;;;;81761:6:0;1397:10;81908:23;81900:68;;;;-1:-1:-1;;;81900:68:0;;;;;;;:::i;:::-;82404:30:::1;82431:1;82404:18;:30::i;:::-;82339:103::o:0;83546:51::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;90301:125::-;81734:7;81761:6;-1:-1:-1;;;;;81761:6:0;1397:10;81908:23;81900:68;;;;-1:-1:-1;;;81900:68:0;;;;;;;:::i;:::-;90383:26:::1;:35:::0;90301:125::o;7478:104::-;7534:13;7567:7;7560:14;;;;;:::i;90031:103::-;81734:7;81761:6;-1:-1:-1;;;;;81761:6:0;1397:10;81908:23;81900:68;;;;-1:-1:-1;;;81900:68:0;;;;;;;:::i;:::-;90100:26:::1;90106:10;90119:6;90100:5;:26::i;87145:110::-:0;81734:7;81761:6;-1:-1:-1;;;;;81761:6:0;1397:10;81908:23;81900:68;;;;-1:-1:-1;;;81900:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;87218:21:0::1;87242:5;87218:21:::0;;;:11:::1;:21;::::0;;;;:29;;-1:-1:-1;;87218:29:0::1;::::0;;87145:110::o;11811:436::-;11904:4;1397:10;11904:4;11987:25;1397:10;12004:7;11987:9;:25::i;:::-;11960:52;;12051:15;12031:16;:35;;12023:85;;;;-1:-1:-1;;;12023:85:0;;13803:2:1;12023:85:0;;;13785:21:1;13842:2;13822:18;;;13815:30;13881:34;13861:18;;;13854:62;-1:-1:-1;;;13932:18:1;;;13925:35;13977:19;;12023:85:0;13601:401:1;12023:85:0;12144:60;12153:5;12160:7;12188:15;12169:16;:34;12144:8;:60::i;:::-;-1:-1:-1;12235:4:0;;11811:436;-1:-1:-1;;;;11811:436:0:o;87296:433::-;87374:4;81761:6;;-1:-1:-1;;;;;81761:6:0;1397:10;87395:23;;;;:53;;-1:-1:-1;1397:10:0;87423:25;;;;:11;:25;;;;;;;;87422:26;87395:53;87391:309;;;87465:14;87482:34;87512:3;87482:25;87493:13;;87482:6;:10;;:25;;;;:::i;:34::-;87465:51;;87531:31;87546:7;81734;81761:6;-1:-1:-1;;;;;81761:6:0;;81688:87;87546:7;87555:6;87531:14;:31::i;:::-;-1:-1:-1;87577:45:0;87592:9;87603:18;:6;87614;87603:10;:18::i;:::-;87577:14;:45::i;:::-;;87450:184;87391:309;;;87655:33;87670:9;87681:6;87655:14;:33::i;:::-;;87391:309;-1:-1:-1;87717:4:0;87296:433;;;;:::o;88649:1101::-;88750:10;8633:7;8660:18;;;:9;:18;;;;;;88765:6;-1:-1:-1;88740:31:0;88732:79;;;;-1:-1:-1;;;88732:79:0;;14209:2:1;88732:79:0;;;14191:21:1;14248:2;14228:18;;;14221:30;14287:34;14267:18;;;14260:62;-1:-1:-1;;;14338:18:1;;;14331:32;14380:19;;88732:79:0;14007:398:1;88732:79:0;88830:29;;;88869:1;88830:29;;;:19;:29;;;;;:36;;;;;:::i;:::-;;;:40;88822:99;;;;-1:-1:-1;;;88822:99:0;;14612:2:1;88822:99:0;;;14594:21:1;14651:2;14631:18;;;14624:30;14690:34;14670:18;;;14663:62;-1:-1:-1;;;14741:18:1;;;14734:44;14795:19;;88822:99:0;14410:410:1;88822:99:0;88957:31;;;88968:10;88957:31;;;12318:51:1;12385:18;;;12378:34;;;88957:31:0;;;;;;;;;12291:18:1;;;88957:31:0;;89085:26;;-1:-1:-1;;;89059:53:0;;;12578:51:1;12645:11;;;;12638:27;;;;89059:53:0;;;;;;;;;;12681:12:1;;;89059:53:0;;;;89147:8;;-1:-1:-1;;;89147:77:0;;;88957:31;;89018:1;;-1:-1:-1;;;;;;;89147:8:0;;:21;;:77;;89169:8;;89187:4;;88957:31;;-1:-1:-1;;89059:53:0;;89147:77;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;89125:99;;;89266:10;89253:9;:23;;89245:107;;;;-1:-1:-1;;;89245:107:0;;15027:2:1;89245:107:0;;;15009:21:1;15066:2;15046:18;;;15039:30;15105:34;15085:18;;;15078:62;15176:34;15156:18;;;15149:62;-1:-1:-1;;;15227:19:1;;;15220:38;15275:19;;89245:107:0;14825:475:1;89245:107:0;89365:8;;89461:29;;;89365:8;89461:29;;;:19;:29;;;;;;89365:340;;-1:-1:-1;;;89365:340:0;;-1:-1:-1;;;;;89365:8:0;;;;:13;;89386:9;;89365:340;;89411:8;;89511:7;;89568:10;;89365:8;89659:13;;89365:340;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89716:26;89722:10;89735:6;89716:5;:26::i;:::-;88721:1029;;;;88649:1101;;:::o;85493:758::-;85709:27;;;85674:32;85709:27;;;:14;:27;;;;;;:40;;;;85737:11;;85709:40;:::i;:::-;;;;;;;;;;;;;;;;:48;;;;;;;;;;;85776:21;;;;85709:48;;-1:-1:-1;85768:86:0;;;;-1:-1:-1;;;85768:86:0;;17032:2:1;85768:86:0;;;17014:21:1;17071:2;17051:18;;;17044:30;17110:34;17090:18;;;17083:62;-1:-1:-1;;;17161:18:1;;;17154:36;17207:19;;85768:86:0;16830:402:1;85768:86:0;85892:23;;85873:42;;:90;;;;;85942:9;:21;;;85929:8;;85919:19;;;;;;;:::i;:::-;;;;;;;;:44;85873:90;85865:129;;;;-1:-1:-1;;;85865:129:0;;17715:2:1;85865:129:0;;;17697:21:1;17754:2;17734:18;;;17727:30;17793:28;17773:18;;;17766:56;17839:18;;85865:129:0;17513:350:1;85865:129:0;86068:1;86042:27;;;86080:21;;;:34;86183:60;;-1:-1:-1;;;86183:60:0;;:4;;:16;;:60;;86200:11;;86213;;86226:6;;86234:8;;;;86183:60;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;85618:633;85493:758;;;;;:::o;9148:151::-;-1:-1:-1;;;;;9264:18:0;;;9237:7;9264:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;9148:151::o;86259:158::-;81734:7;81761:6;-1:-1:-1;;;;;81761:6:0;1397:10;81908:23;81900:68;;;;-1:-1:-1;;;81900:68:0;;;;;;;:::i;:::-;86363:29:::1;::::0;::::1;;::::0;;;:19:::1;:29;::::0;;;;:46:::1;86395:14:::0;;86363:29;:46:::1;:::i;82597:201::-:0;81734:7;81761:6;-1:-1:-1;;;;;81761:6:0;1397:10;81908:23;81900:68;;;;-1:-1:-1;;;81900:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;82686:22:0;::::1;82678:73;;;::::0;-1:-1:-1;;;82678:73:0;;20720:2:1;82678:73:0::1;::::0;::::1;20702:21:1::0;20759:2;20739:18;;;20732:30;20798:34;20778:18;;;20771:62;-1:-1:-1;;;20849:18:1;;;20842:36;20895:19;;82678:73:0::1;20518:402:1::0;82678:73:0::1;82762:28;82781:8;82762:18;:28::i;15804:346::-:0;-1:-1:-1;;;;;15906:19:0;;15898:68;;;;-1:-1:-1;;;15898:68:0;;21127:2:1;15898:68:0;;;21109:21:1;21166:2;21146:18;;;21139:30;21205:34;21185:18;;;21178:62;-1:-1:-1;;;21256:18:1;;;21249:34;21300:19;;15898:68:0;20925:400:1;15898:68:0;-1:-1:-1;;;;;15985:21:0;;15977:68;;;;-1:-1:-1;;;15977:68:0;;21532:2:1;15977:68:0;;;21514:21:1;21571:2;21551:18;;;21544:30;21610:34;21590:18;;;21583:62;-1:-1:-1;;;21661:18:1;;;21654:32;21703:19;;15977:68:0;21330:398:1;15977:68:0;-1:-1:-1;;;;;16058:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;16110:32;;3443:25:1;;;16110:32:0;;3416:18:1;16110:32:0;;;;;;;;15804:346;;;:::o;89756:269::-;89909:14;89925;89954:8;89943:40;;;;;;;;;;;;:::i;:::-;89908:75;;;;89994:21;90000:6;90008;89994:5;:21::i;32765:98::-;32823:7;32850:5;32854:1;32850;:5;:::i;:::-;32843:12;32765:98;-1:-1:-1;;;32765:98:0:o;33164:::-;33222:7;33249:5;33253:1;33249;:5;:::i;10400:261::-;10497:4;1397:10;10555:38;10571:4;1397:10;10586:6;10555:15;:38::i;:::-;10604:27;10614:4;10620:2;10624:6;10604:9;:27::i;32408:98::-;32466:7;32493:5;32497:1;32493;:5;:::i;82958:191::-;83032:16;83051:6;;-1:-1:-1;;;;;83068:17:0;;;-1:-1:-1;;;;;;83068:17:0;;;;;;83101:40;;83051:6;;;;;;;83101:40;;83032:16;83101:40;83021:128;82958:191;:::o;13810:548::-;-1:-1:-1;;;;;13894:21:0;;13886:65;;;;-1:-1:-1;;;13886:65:0;;22785:2:1;13886:65:0;;;22767:21:1;22824:2;22804:18;;;22797:30;22863:33;22843:18;;;22836:61;22914:18;;13886:65:0;22583:355:1;13886:65:0;14042:6;14026:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;14197:18:0;;;;;;:9;:18;;;;;;;;:28;;;;;;14252:37;3443:25:1;;;14252:37:0;;3416:18:1;14252:37:0;;;;;;;13810:548;;:::o;8892:193::-;8971:4;1397:10;9027:28;1397:10;9044:2;9048:6;9027:9;:28::i;14691:675::-;-1:-1:-1;;;;;14775:21:0;;14767:67;;;;-1:-1:-1;;;14767:67:0;;23145:2:1;14767:67:0;;;23127:21:1;23184:2;23164:18;;;23157:30;23223:34;23203:18;;;23196:62;-1:-1:-1;;;23274:18:1;;;23267:31;23315:19;;14767:67:0;22943:397:1;14767:67:0;-1:-1:-1;;;;;14934:18:0;;14909:22;14934:18;;;:9;:18;;;;;;14971:24;;;;14963:71;;;;-1:-1:-1;;;14963:71:0;;23547:2:1;14963:71:0;;;23529:21:1;23586:2;23566:18;;;23559:30;23625:34;23605:18;;;23598:62;-1:-1:-1;;;23676:18:1;;;23669:32;23718:19;;14963:71:0;23345:398:1;14963:71:0;-1:-1:-1;;;;;15070:18:0;;;;;;:9;:18;;;;;;;;15091:23;;;15070:44;;15209:12;:22;;;;;;;15260:37;3443:25:1;;;15070:18:0;;;15260:37;;3416:18:1;15260:37:0;3297:177:1;15310:48:0;14756:610;14691:675;;:::o;16441:419::-;16542:24;16569:25;16579:5;16586:7;16569:9;:25::i;:::-;16542:52;;-1:-1:-1;;16609:16:0;:37;16605:248;;16691:6;16671:16;:26;;16663:68;;;;-1:-1:-1;;;16663:68:0;;23950:2:1;16663:68:0;;;23932:21:1;23989:2;23969:18;;;23962:30;24028:31;24008:18;;;24001:59;24077:18;;16663:68:0;23748:353:1;16663:68:0;16775:51;16784:5;16791:7;16819:6;16800:16;:25;16775:8;:51::i;12717:806::-;-1:-1:-1;;;;;12814:18:0;;12806:68;;;;-1:-1:-1;;;12806:68:0;;24308:2:1;12806:68:0;;;24290:21:1;24347:2;24327:18;;;24320:30;24386:34;24366:18;;;24359:62;-1:-1:-1;;;24437:18:1;;;24430:35;24482:19;;12806:68:0;24106:401:1;12806:68:0;-1:-1:-1;;;;;12893:16:0;;12885:64;;;;-1:-1:-1;;;12885:64:0;;24714:2:1;12885:64:0;;;24696:21:1;24753:2;24733:18;;;24726:30;24792:34;24772:18;;;24765:62;-1:-1:-1;;;24843:18:1;;;24836:33;24886:19;;12885:64:0;24512:399:1;12885:64:0;-1:-1:-1;;;;;13035:15:0;;13013:19;13035:15;;;:9;:15;;;;;;13069:21;;;;13061:72;;;;-1:-1:-1;;;13061:72:0;;25118:2:1;13061:72:0;;;25100:21:1;25157:2;25137:18;;;25130:30;25196:34;25176:18;;;25169:62;-1:-1:-1;;;25247:18:1;;;25240:36;25293:19;;13061:72:0;24916:402:1;13061:72:0;-1:-1:-1;;;;;13169:15:0;;;;;;;:9;:15;;;;;;13187:20;;;13169:38;;13387:13;;;;;;;;;;:23;;;;;;13439:26;;;;;;13201:6;3443:25:1;;3431:2;3416:18;;3297:177;13439:26:0;;;;;;;;13478:37;14691:675;14:159:1;81:20;;141:6;130:18;;120:29;;110:57;;163:1;160;153:12;110:57;14:159;;;:::o;178:127::-;239:10;234:3;230:20;227:1;220:31;270:4;267:1;260:15;294:4;291:1;284:15;310:718;352:5;405:3;398:4;390:6;386:17;382:27;372:55;;423:1;420;413:12;372:55;459:6;446:20;485:18;522:2;518;515:10;512:36;;;528:18;;:::i;:::-;603:2;597:9;571:2;657:13;;-1:-1:-1;;653:22:1;;;677:2;649:31;645:40;633:53;;;701:18;;;721:22;;;698:46;695:72;;;747:18;;:::i;:::-;787:10;783:2;776:22;822:2;814:6;807:18;868:3;861:4;856:2;848:6;844:15;840:26;837:35;834:55;;;885:1;882;875:12;834:55;949:2;942:4;934:6;930:17;923:4;915:6;911:17;898:54;996:1;989:4;984:2;976:6;972:15;968:26;961:37;1016:6;1007:15;;;;;;310:718;;;;:::o;1033:171::-;1100:20;;1160:18;1149:30;;1139:41;;1129:69;;1194:1;1191;1184:12;1209:684;1311:6;1319;1327;1335;1388:3;1376:9;1367:7;1363:23;1359:33;1356:53;;;1405:1;1402;1395:12;1356:53;1428:28;1446:9;1428:28;:::i;:::-;1418:38;;1507:2;1496:9;1492:18;1479:32;1530:18;1571:2;1563:6;1560:14;1557:34;;;1587:1;1584;1577:12;1557:34;1610:49;1651:7;1642:6;1631:9;1627:22;1610:49;:::i;:::-;1600:59;;1678:37;1711:2;1700:9;1696:18;1678:37;:::i;:::-;1668:47;;1768:2;1757:9;1753:18;1740:32;1724:48;;1797:2;1787:8;1784:16;1781:36;;;1813:1;1810;1803:12;1781:36;;1836:51;1879:7;1868:8;1857:9;1853:24;1836:51;:::i;:::-;1826:61;;;1209:684;;;;;;;:::o;1898:258::-;1970:1;1980:113;1994:6;1991:1;1988:13;1980:113;;;2070:11;;;2064:18;2051:11;;;2044:39;2016:2;2009:10;1980:113;;;2111:6;2108:1;2105:13;2102:48;;;-1:-1:-1;;2146:1:1;2128:16;;2121:27;1898:258::o;2161:::-;2203:3;2241:5;2235:12;2268:6;2263:3;2256:19;2284:63;2340:6;2333:4;2328:3;2324:14;2317:4;2310:5;2306:16;2284:63;:::i;:::-;2401:2;2380:15;-1:-1:-1;;2376:29:1;2367:39;;;;2408:4;2363:50;;2161:258;-1:-1:-1;;2161:258:1:o;2424:220::-;2573:2;2562:9;2555:21;2536:4;2593:45;2634:2;2623:9;2619:18;2611:6;2593:45;:::i;2649:131::-;-1:-1:-1;;;;;2724:31:1;;2714:42;;2704:70;;2770:1;2767;2760:12;2785:315;2853:6;2861;2914:2;2902:9;2893:7;2889:23;2885:32;2882:52;;;2930:1;2927;2920:12;2882:52;2969:9;2956:23;2988:31;3013:5;2988:31;:::i;:::-;3038:5;3090:2;3075:18;;;;3062:32;;-1:-1:-1;;;2785:315:1:o;3479:456::-;3556:6;3564;3572;3625:2;3613:9;3604:7;3600:23;3596:32;3593:52;;;3641:1;3638;3631:12;3593:52;3680:9;3667:23;3699:31;3724:5;3699:31;:::i;:::-;3749:5;-1:-1:-1;3806:2:1;3791:18;;3778:32;3819:33;3778:32;3819:33;:::i;:::-;3479:456;;3871:7;;-1:-1:-1;;;3925:2:1;3910:18;;;;3897:32;;3479:456::o;4129:252::-;4196:6;4204;4257:2;4245:9;4236:7;4232:23;4228:32;4225:52;;;4273:1;4270;4263:12;4225:52;4296:28;4314:9;4296:28;:::i;4386:247::-;4445:6;4498:2;4486:9;4477:7;4473:23;4469:32;4466:52;;;4514:1;4511;4504:12;4466:52;4553:9;4540:23;4572:31;4597:5;4572:31;:::i;4638:184::-;4696:6;4749:2;4737:9;4728:7;4724:23;4720:32;4717:52;;;4765:1;4762;4755:12;4717:52;4788:28;4806:9;4788:28;:::i;5367:460::-;5452:6;5460;5468;5521:2;5509:9;5500:7;5496:23;5492:32;5489:52;;;5537:1;5534;5527:12;5489:52;5560:28;5578:9;5560:28;:::i;:::-;5550:38;;5639:2;5628:9;5624:18;5611:32;5666:18;5658:6;5655:30;5652:50;;;5698:1;5695;5688:12;5652:50;5721:49;5762:7;5753:6;5742:9;5738:22;5721:49;:::i;:::-;5711:59;;;5817:2;5806:9;5802:18;5789:32;5779:42;;5367:460;;;;;:::o;6085:180::-;6144:6;6197:2;6185:9;6176:7;6172:23;6168:32;6165:52;;;6213:1;6210;6203:12;6165:52;-1:-1:-1;6236:23:1;;6085:180;-1:-1:-1;6085:180:1:o;6270:347::-;6321:8;6331:6;6385:3;6378:4;6370:6;6366:17;6362:27;6352:55;;6403:1;6400;6393:12;6352:55;-1:-1:-1;6426:20:1;;6469:18;6458:30;;6455:50;;;6501:1;6498;6491:12;6455:50;6538:4;6530:6;6526:17;6514:29;;6590:3;6583:4;6574:6;6566;6562:19;6558:30;6555:39;6552:59;;;6607:1;6604;6597:12;6552:59;6270:347;;;;;:::o;6622:773::-;6726:6;6734;6742;6750;6758;6811:3;6799:9;6790:7;6786:23;6782:33;6779:53;;;6828:1;6825;6818:12;6779:53;6851:28;6869:9;6851:28;:::i;:::-;6841:38;;6930:2;6919:9;6915:18;6902:32;6953:18;6994:2;6986:6;6983:14;6980:34;;;7010:1;7007;7000:12;6980:34;7033:49;7074:7;7065:6;7054:9;7050:22;7033:49;:::i;:::-;7023:59;;7101:37;7134:2;7123:9;7119:18;7101:37;:::i;:::-;7091:47;;7191:2;7180:9;7176:18;7163:32;7147:48;;7220:2;7210:8;7207:16;7204:36;;;7236:1;7233;7226:12;7204:36;;7275:60;7327:7;7316:8;7305:9;7301:24;7275:60;:::i;:::-;6622:773;;;;-1:-1:-1;6622:773:1;;-1:-1:-1;7354:8:1;;7249:86;6622:773;-1:-1:-1;;;6622:773:1:o;7400:388::-;7468:6;7476;7529:2;7517:9;7508:7;7504:23;7500:32;7497:52;;;7545:1;7542;7535:12;7497:52;7584:9;7571:23;7603:31;7628:5;7603:31;:::i;:::-;7653:5;-1:-1:-1;7710:2:1;7695:18;;7682:32;7723:33;7682:32;7723:33;:::i;:::-;7775:7;7765:17;;;7400:388;;;;;:::o;7793:481::-;7871:6;7879;7887;7940:2;7928:9;7919:7;7915:23;7911:32;7908:52;;;7956:1;7953;7946:12;7908:52;7979:28;7997:9;7979:28;:::i;:::-;7969:38;;8058:2;8047:9;8043:18;8030:32;8085:18;8077:6;8074:30;8071:50;;;8117:1;8114;8107:12;8071:50;8156:58;8206:7;8197:6;8186:9;8182:22;8156:58;:::i;:::-;7793:481;;8233:8;;-1:-1:-1;8130:84:1;;-1:-1:-1;;;;7793:481:1:o;8279:380::-;8358:1;8354:12;;;;8401;;;8422:61;;8476:4;8468:6;8464:17;8454:27;;8422:61;8529:2;8521:6;8518:14;8498:18;8495:38;8492:161;;8575:10;8570:3;8566:20;8563:1;8556:31;8610:4;8607:1;8600:15;8638:4;8635:1;8628:15;8492:161;;8279:380;;;:::o;8789:840::-;8915:3;8944:1;8977:6;8971:13;9007:36;9033:9;9007:36;:::i;:::-;9062:1;9079:18;;;9106:133;;;;9253:1;9248:356;;;;9072:532;;9106:133;-1:-1:-1;;9139:24:1;;9127:37;;9212:14;;9205:22;9193:35;;9184:45;;;-1:-1:-1;9106:133:1;;9248:356;9279:6;9276:1;9269:17;9309:4;9354:2;9351:1;9341:16;9379:1;9393:165;9407:6;9404:1;9401:13;9393:165;;;9485:14;;9472:11;;;9465:35;9528:16;;;;9422:10;;9393:165;;;9397:3;;;9587:6;9582:3;9578:16;9571:23;;9072:532;-1:-1:-1;9620:3:1;;8789:840;-1:-1:-1;;;;;;8789:840:1:o;10055:557::-;10312:6;10304;10300:19;10289:9;10282:38;10356:3;10351:2;10340:9;10336:18;10329:31;10263:4;10383:46;10424:3;10413:9;10409:19;10401:6;10383:46;:::i;:::-;10477:18;10469:6;10465:31;10460:2;10449:9;10445:18;10438:59;10545:9;10537:6;10533:22;10528:2;10517:9;10513:18;10506:50;10573:33;10599:6;10591;10573:33;:::i;:::-;10565:41;10055:557;-1:-1:-1;;;;;;;10055:557:1:o;10617:274::-;10746:3;10784:6;10778:13;10800:53;10846:6;10841:3;10834:4;10826:6;10822:17;10800:53;:::i;:::-;10869:16;;;;;10617:274;-1:-1:-1;;10617:274:1:o;11308:127::-;11369:10;11364:3;11360:20;11357:1;11350:31;11400:4;11397:1;11390:15;11424:4;11421:1;11414:15;11440:128;11480:3;11511:1;11507:6;11504:1;11501:13;11498:39;;;11517:18;;:::i;:::-;-1:-1:-1;11553:9:1;;11440:128::o;11573:356::-;11775:2;11757:21;;;11794:18;;;11787:30;11853:34;11848:2;11833:18;;11826:62;11920:2;11905:18;;11573:356::o;12704:642::-;12985:6;12973:19;;12955:38;;-1:-1:-1;;;;;13029:32:1;;13024:2;13009:18;;13002:60;13049:3;13093:2;13078:18;;13071:31;;;-1:-1:-1;;13125:46:1;;13151:19;;13143:6;13125:46;:::i;:::-;13221:6;13214:14;13207:22;13202:2;13191:9;13187:18;13180:50;13279:9;13271:6;13267:22;13261:3;13250:9;13246:19;13239:51;13307:33;13333:6;13325;13307:33;:::i;:::-;13299:41;12704:642;-1:-1:-1;;;;;;;;12704:642:1:o;13351:245::-;13430:6;13438;13491:2;13479:9;13470:7;13466:23;13462:32;13459:52;;;13507:1;13504;13497:12;13459:52;-1:-1:-1;;13530:16:1;;13586:2;13571:18;;;13565:25;13530:16;;13565:25;;-1:-1:-1;13351:245:1:o;15305:1520::-;15651:6;15643;15639:19;15628:9;15621:38;15602:4;15678:2;15716:3;15711:2;15700:9;15696:18;15689:31;15740:1;15773:6;15767:13;15803:36;15829:9;15803:36;:::i;:::-;15876:6;15870:3;15859:9;15855:19;15848:35;15902:3;15924:1;15956:2;15945:9;15941:18;15973:1;15968:158;;;;16140:1;16135:354;;;;15934:555;;15968:158;-1:-1:-1;;16016:24:1;;15996:18;;;15989:52;16094:14;;16087:22;16084:1;16080:30;16065:46;;16061:55;;;-1:-1:-1;15968:158:1;;16135:354;16166:6;16163:1;16156:17;16214:2;16211:1;16201:16;16239:1;16253:180;16267:6;16264:1;16261:13;16253:180;;;16360:14;;16336:17;;;16332:26;;16325:50;16403:16;;;;16282:10;;16253:180;;;16457:17;;16453:26;;;-1:-1:-1;;15934:555:1;;;;;;16534:9;16529:3;16525:19;16520:2;16509:9;16505:18;16498:47;16568:30;16594:3;16586:6;16568:30;:::i;:::-;16554:44;;;16607:46;16649:2;16638:9;16634:18;16626:6;-1:-1:-1;;;;;5116:31:1;5104:44;;5050:104;16607:46;-1:-1:-1;;;;;5116:31:1;;16704:3;16689:19;;5104:44;16758:9;16750:6;16746:22;16740:3;16729:9;16725:19;16718:51;16786:33;16812:6;16804;16786:33;:::i;:::-;16778:41;15305:1520;-1:-1:-1;;;;;;;;;15305:1520:1:o;17237:271::-;17420:6;17412;17407:3;17394:33;17376:3;17446:16;;17471:13;;;17446:16;17237:271;-1:-1:-1;17237:271:1:o;17868:718::-;18135:6;18127;18123:19;18112:9;18105:38;18179:3;18174:2;18163:9;18159:18;18152:31;18086:4;18206:46;18247:3;18236:9;18232:19;18224:6;18206:46;:::i;:::-;18300:18;18292:6;18288:31;18283:2;18272:9;18268:18;18261:59;18368:9;18360:6;18356:22;18351:2;18340:9;18336:18;18329:50;18403:6;18395;18388:22;18457:6;18449;18444:2;18436:6;18432:15;18419:45;18510:1;18505:2;18496:6;18488;18484:19;18480:28;18473:39;18577:2;18570;18566:7;18561:2;18553:6;18549:15;18545:29;18537:6;18533:42;18529:51;18521:59;;;17868:718;;;;;;;;:::o;18591:544::-;18692:2;18687:3;18684:11;18681:448;;;18728:1;18753:5;18749:2;18742:17;18798:4;18794:2;18784:19;18868:2;18856:10;18852:19;18849:1;18845:27;18839:4;18835:38;18904:4;18892:10;18889:20;18886:47;;;-1:-1:-1;18927:4:1;18886:47;18982:2;18977:3;18973:12;18970:1;18966:20;18960:4;18956:31;18946:41;;19037:82;19055:2;19048:5;19045:13;19037:82;;;19100:17;;;19081:1;19070:13;19037:82;;19311:1202;19433:18;19428:3;19425:27;19422:53;;;19455:18;;:::i;:::-;19484:93;19573:3;19533:38;19565:4;19559:11;19533:38;:::i;:::-;19527:4;19484:93;:::i;:::-;19603:1;19628:2;19623:3;19620:11;19645:1;19640:615;;;;20299:1;20316:3;20313:93;;;-1:-1:-1;20372:19:1;;;20359:33;20313:93;-1:-1:-1;;19268:1:1;19264:11;;;19260:24;19256:29;19246:40;19292:1;19288:11;;;19243:57;20419:78;;19613:894;;19640:615;8736:1;8729:14;;;8773:4;8760:18;;-1:-1:-1;;19676:17:1;;;19776:9;19798:229;19812:7;19809:1;19806:14;19798:229;;;19901:19;;;19888:33;19873:49;;20008:4;19993:20;;;;19961:1;19949:14;;;;19828:12;19798:229;;;19802:3;20055;20046:7;20043:16;20040:159;;;20179:1;20175:6;20169:3;20163;20160:1;20156:11;20152:21;20148:34;20144:39;20131:9;20126:3;20122:19;20109:33;20105:79;20097:6;20090:95;20040:159;;;20242:1;20236:3;20233:1;20229:11;20225:19;20219:4;20212:33;19613:894;;;19311:1202;;;:::o;21733:320::-;21820:6;21828;21881:2;21869:9;21860:7;21856:23;21852:32;21849:52;;;21897:1;21894;21887:12;21849:52;21929:9;21923:16;21948:31;21973:5;21948:31;:::i;:::-;22043:2;22028:18;;;;22022:25;21998:5;;22022:25;;-1:-1:-1;;;21733:320:1:o;22058:168::-;22098:7;22164:1;22160;22156:6;22152:14;22149:1;22146:21;22141:1;22134:9;22127:17;22123:45;22120:71;;;22171:18;;:::i;:::-;-1:-1:-1;22211:9:1;;22058:168::o;22231:217::-;22271:1;22297;22287:132;;22341:10;22336:3;22332:20;22329:1;22322:31;22376:4;22373:1;22366:15;22404:4;22401:1;22394:15;22287:132;-1:-1:-1;22433:9:1;;22231:217::o;22453:125::-;22493:4;22521:1;22518;22515:8;22512:34;;;22526:18;;:::i;:::-;-1:-1:-1;22563:9:1;;22453:125::o

Swarm Source

ipfs://cf7c51b55eedbcf7a581a490868547841b6007c18623da4ff9504437ba1a01ed

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services