Contract

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/Context.sol";

contract OBSource is ReentrancyGuard, Context {
    function transfer(address payable _to, bytes calldata _ext)
        public
        payable
        nonReentrant
    {
        (bool sent, ) = _to.call{value: msg.value}("");
        require(sent, "ERROR");
    }

    function transferERC20(
        IERC20 _token,
        address _to,
        uint256 _amount,
        bytes calldata _ext
    ) external nonReentrant {
        bool sent = _token.transferFrom(msg.sender, _to, _amount);
        require(sent, "ERROR");
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;

import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20.sol";

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

// SPDX-License-Identifier: MIT
// 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);
}

// SPDX-License-Identifier: MIT
// 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;
    }
}

//SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract OBERC20 is ERC20 {
    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_)
        ERC20(name_, symbol_)
    {}

    function mint(address account, uint256 amount) public virtual {
        _mint(account, amount);
    }
}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address payable","name":"_to","type":"address"},{"internalType":"bytes","name":"_ext","type":"bytes"}],"name":"transfer","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"bytes","name":"_ext","type":"bytes"}],"name":"transferERC20","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

235:526:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;287:211;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;504:255;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;287:211;2261:21:0;:19;:21::i;:::-;414:9:6::1;429:3;:8;;445:9;429:30;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;413:46;;;477:4;469:22;;;;;;;;;;;;:::i;:::-;;;;;;;;;403:95;2303:20:0::0;:18;:20::i;:::-;287:211:6;;;:::o;504:255::-;2261:21:0;:19;:21::i;:::-;663:9:6::1;675:6;:19;;;695:10;707:3;712:7;675:45;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;663:57;;738:4;730:22;;;;;;;;;;;;:::i;:::-;;;;;;;;;653:106;2303:20:0::0;:18;:20::i;:::-;504:255:6;;;;;:::o;2336:287:0:-;1759:1;2468:7;;:19;2460:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;1759:1;2598:7;:18;;;;2336:287::o;2629:209::-;1716:1;2809:7;:22;;;;2629:209::o;88:117:7:-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:104::-;511:7;540:24;558:5;540:24;:::i;:::-;529:35;;466:104;;;:::o;576:138::-;657:32;683:5;657:32;:::i;:::-;650:5;647:43;637:71;;704:1;701;694:12;637:71;576:138;:::o;720:155::-;774:5;812:6;799:20;790:29;;828:41;863:5;828:41;:::i;:::-;720:155;;;;:::o;881:117::-;990:1;987;980:12;1004:117;1113:1;1110;1103:12;1127:117;1236:1;1233;1226:12;1263:552;1320:8;1330:6;1380:3;1373:4;1365:6;1361:17;1357:27;1347:122;;1388:79;;:::i;:::-;1347:122;1501:6;1488:20;1478:30;;1531:18;1523:6;1520:30;1517:117;;;1553:79;;:::i;:::-;1517:117;1667:4;1659:6;1655:17;1643:29;;1721:3;1713:4;1705:6;1701:17;1691:8;1687:32;1684:41;1681:128;;;1728:79;;:::i;:::-;1681:128;1263:552;;;;;:::o;1821:688::-;1908:6;1916;1924;1973:2;1961:9;1952:7;1948:23;1944:32;1941:119;;;1979:79;;:::i;:::-;1941:119;2099:1;2124:61;2177:7;2168:6;2157:9;2153:22;2124:61;:::i;:::-;2114:71;;2070:125;2262:2;2251:9;2247:18;2234:32;2293:18;2285:6;2282:30;2279:117;;;2315:79;;:::i;:::-;2279:117;2428:64;2484:7;2475:6;2464:9;2460:22;2428:64;:::i;:::-;2410:82;;;;2205:297;1821:688;;;;;:::o;2515:96::-;2552:7;2581:24;2599:5;2581:24;:::i;:::-;2570:35;;2515:96;;;:::o;2617:110::-;2668:7;2697:24;2715:5;2697:24;:::i;:::-;2686:35;;2617:110;;;:::o;2733:150::-;2820:38;2852:5;2820:38;:::i;:::-;2813:5;2810:49;2800:77;;2873:1;2870;2863:12;2800:77;2733:150;:::o;2889:167::-;2949:5;2987:6;2974:20;2965:29;;3003:47;3044:5;3003:47;:::i;:::-;2889:167;;;;:::o;3062:122::-;3135:24;3153:5;3135:24;:::i;:::-;3128:5;3125:35;3115:63;;3174:1;3171;3164:12;3115:63;3062:122;:::o;3190:139::-;3236:5;3274:6;3261:20;3252:29;;3290:33;3317:5;3290:33;:::i;:::-;3190:139;;;;:::o;3335:77::-;3372:7;3401:5;3390:16;;3335:77;;;:::o;3418:122::-;3491:24;3509:5;3491:24;:::i;:::-;3484:5;3481:35;3471:63;;3530:1;3527;3520:12;3471:63;3418:122;:::o;3546:139::-;3592:5;3630:6;3617:20;3608:29;;3646:33;3673:5;3646:33;:::i;:::-;3546:139;;;;:::o;3691:991::-;3802:6;3810;3818;3826;3834;3883:3;3871:9;3862:7;3858:23;3854:33;3851:120;;;3890:79;;:::i;:::-;3851:120;4010:1;4035:67;4094:7;4085:6;4074:9;4070:22;4035:67;:::i;:::-;4025:77;;3981:131;4151:2;4177:53;4222:7;4213:6;4202:9;4198:22;4177:53;:::i;:::-;4167:63;;4122:118;4279:2;4305:53;4350:7;4341:6;4330:9;4326:22;4305:53;:::i;:::-;4295:63;;4250:118;4435:2;4424:9;4420:18;4407:32;4466:18;4458:6;4455:30;4452:117;;;4488:79;;:::i;:::-;4452:117;4601:64;4657:7;4648:6;4637:9;4633:22;4601:64;:::i;:::-;4583:82;;;;4378:297;3691:991;;;;;;;;:::o;4688:147::-;4789:11;4826:3;4811:18;;4688:147;;;;:::o;4841:114::-;;:::o;4961:398::-;5120:3;5141:83;5222:1;5217:3;5141:83;:::i;:::-;5134:90;;5233:93;5322:3;5233:93;:::i;:::-;5351:1;5346:3;5342:11;5335:18;;4961:398;;;:::o;5365:379::-;5549:3;5571:147;5714:3;5571:147;:::i;:::-;5564:154;;5735:3;5728:10;;5365:379;;;:::o;5750:169::-;5834:11;5868:6;5863:3;5856:19;5908:4;5903:3;5899:14;5884:29;;5750:169;;;;:::o;5925:155::-;6065:7;6061:1;6053:6;6049:14;6042:31;5925:155;:::o;6086:365::-;6228:3;6249:66;6313:1;6308:3;6249:66;:::i;:::-;6242:73;;6324:93;6413:3;6324:93;:::i;:::-;6442:2;6437:3;6433:12;6426:19;;6086:365;;;:::o;6457:419::-;6623:4;6661:2;6650:9;6646:18;6638:26;;6710:9;6704:4;6700:20;6696:1;6685:9;6681:17;6674:47;6738:131;6864:4;6738:131;:::i;:::-;6730:139;;6457:419;;;:::o;6882:118::-;6969:24;6987:5;6969:24;:::i;:::-;6964:3;6957:37;6882:118;;:::o;7006:::-;7093:24;7111:5;7093:24;:::i;:::-;7088:3;7081:37;7006:118;;:::o;7130:442::-;7279:4;7317:2;7306:9;7302:18;7294:26;;7330:71;7398:1;7387:9;7383:17;7374:6;7330:71;:::i;:::-;7411:72;7479:2;7468:9;7464:18;7455:6;7411:72;:::i;:::-;7493;7561:2;7550:9;7546:18;7537:6;7493:72;:::i;:::-;7130:442;;;;;;:::o;7578:90::-;7612:7;7655:5;7648:13;7641:21;7630:32;;7578:90;;;:::o;7674:116::-;7744:21;7759:5;7744:21;:::i;:::-;7737:5;7734:32;7724:60;;7780:1;7777;7770:12;7724:60;7674:116;:::o;7796:137::-;7850:5;7881:6;7875:13;7866:22;;7897:30;7921:5;7897:30;:::i;:::-;7796:137;;;;:::o;7939:345::-;8006:6;8055:2;8043:9;8034:7;8030:23;8026:32;8023:119;;;8061:79;;:::i;:::-;8023:119;8181:1;8206:61;8259:7;8250:6;8239:9;8235:22;8206:61;:::i;:::-;8196:71;;8152:125;7939:345;;;;:::o;8290:181::-;8430:33;8426:1;8418:6;8414:14;8407:57;8290:181;:::o;8477:366::-;8619:3;8640:67;8704:2;8699:3;8640:67;:::i;:::-;8633:74;;8716:93;8805:3;8716:93;:::i;:::-;8834:2;8829:3;8825:12;8818:19;;8477:366;;;:::o;8849:419::-;9015:4;9053:2;9042:9;9038:18;9030:26;;9102:9;9096:4;9092:20;9088:1;9077:9;9073:17;9066:47;9130:131;9256:4;9130:131;:::i;:::-;9122:139;;8849:419;;;:::o

ipfs://d8e1a6e0386df7f8483373d1e6485b282c7bdebb5c20101919d3ba2a4d8a52c5