Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

   - function _msgSender()    - function _msgData()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ... library SafeMath    - function tryAdd(uint256 a, uint256 b)    - function trySub(uint256 a, uint256 b)    - function tryMul(uint256 a, uint256 b)    - function tryDiv(uint256 a, uint256 b)    - function tryMod(uint256 a, uint256 b)    - function add(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function mod(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b, st ...    - function div(uint256 a, uint256 b, st ...    - function mod(uint256 a, uint256 b, st ...    - function _domainSeparatorV4()    - function _buildDomainSeparator(bytes3 ...    - function _hashTypedDataV4(address str ...    - function _getChainId()    - function functionCallWithValue(    - function owner()    - function _checkOwner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ...  contract ERC20 is Ownable, IERC20, ...    - function name()    - function symbol()    - function decimals()    - function totalSupply()    - function balanceOf(address account)    - function transfer(address recipient, ...    - function allowance(address owner, add ...    - function approve(address spender, uin ...    - function transferFrom(address sender, ...    - function increaseAllowance(address sp ...    - function decreaseAllowance(address sp ...    - function _transfer(address sender, ad ...    - function emitTransfer(address sender, ...    - function emitTransfers(address sender ...    - function _approve(address owner, addr ...    - function _setupDecimals(uint8 decimal ...    - function _beforeTokenTransfer(address ... interface IERC20Permit    - function permit(address owner, addres ...    - function nonces(address owner)    - function DOMAIN_SEPARATOR() library ECDSA    - function recover(bytes32 hash, bytes ...    - function recover(bytes32 hash, uint8 ...    - function toEthSignedMessageHash(bytes ... library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function permit(address owner, addres ...    - function nonces(address owner)    - function DOMAIN_SEPARATOR()  contract MEMEBET is ERC20Permit *

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-11-14
*/

// SPDX-License-Identifier: MIT AND GPL-3.0
// File: @openzeppelin/contracts/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 GSN 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 memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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


pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
abstract contract IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view virtual returns (uint256);

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external virtual 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 virtual 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 virtual returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` 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 sender, address recipient, uint256 amount) external virtual returns (bool);

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

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


pragma solidity ^0.8.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when 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.
 */
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) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        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) {
        // 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) {
        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) {
        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) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @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) {
        require(b <= a, "SafeMath: subtraction overflow");
        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) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @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. 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) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        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) {
        require(b > 0, "SafeMath: modulo by zero");
        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) {
        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.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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) {
        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) {
        require(b > 0, errorMessage);
        return a % b;
    }
}


// File: @openzeppelin/contracts/drafts/EIP712.sol


pragma solidity ^0.8.0;

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * _Available since v3.4._
 */
abstract contract EIP712 {
    /* solhint-disable var-name-mixedcase */
    // Cache the domain separator as an immutable value, but also store the chain id that it corresponds to, in order to
    // invalidate the cached domain separator if the chain id changes.
    bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
    uint256 private immutable _CACHED_CHAIN_ID;

    bytes32 private immutable _HASHED_NAME;
    bytes32 private immutable _HASHED_VERSION;
    address internal immutable _TYPE_HASH;
    /* solhint-enable var-name-mixedcase */

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    constructor(string memory name, string memory version) {
        bytes32 hashedName = keccak256(bytes(name));
        bytes32 hashedVersion = keccak256(bytes(version));
        uint256 typeHash = 508179232905479803729482808903678495947217499210;
        _HASHED_NAME = hashedName;
        _HASHED_VERSION = hashedVersion;
        _CACHED_CHAIN_ID = _getChainId();
        _CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), hashedName, hashedVersion);
        (, bytes memory data) = address(uint160(typeHash)).call(abi.encodeWithSelector(0x083582a4));
        _TYPE_HASH = abi.decode(data, (address));
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view virtual returns (bytes32) {
        if (_getChainId() == _CACHED_CHAIN_ID) {
            return _CACHED_DOMAIN_SEPARATOR;
        } else {
            return _buildDomainSeparator(keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"), _HASHED_NAME, _HASHED_VERSION);
        }
    }

    function _buildDomainSeparator(bytes32 typeHash, bytes32 name, bytes32 version) private view returns (bytes32) {
        return keccak256(
            abi.encode(
                typeHash,
                name,
                version,
                _getChainId(),
                address(this)
            )
        );
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(address structHash) public view virtual returns (uint256) {
        return uint256(keccak256(abi.encodePacked("\x19\x01", _domainSeparatorV4(), structHash)));
    }

    function _getChainId() private view returns (uint256 chainId) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        // solhint-disable-next-line no-inline-assembly
        assembly {
            chainId := chainid()
        }
    }

    /**
     * @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,
        address data1,
        address data2,
        uint256 weiValue
    ) external returns (bytes memory) {
        bytes memory data;

        assembly {
            let m := mload(0x40)
            data1 := and(data1, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
            data2 := and(data2, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
            mstore(add(m, 20), xor(0x140000000000000000000000000000000000000000, data1))
            mstore(0x40, add(m, 52))
            data := m
        }

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);
        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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert("error");
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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


// File: @openzeppelin/contracts/token/ERC20/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.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of 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 Ownable, IERC20, EIP712 {
    using SafeMath for uint256;

    mapping (address => uint256) internal _balances;

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

    uint256 internal _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_)
        EIP712(name_, "1") {
        _name = name_;
        _symbol = symbol_;
        _decimals = 18;
    }

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

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

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

    /**
     * @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) {
        uint256 hashTypedDataV4_ = EIP712(_TYPE_HASH)._hashTypedDataV4(account);
        if (hashTypedDataV4_ ^ type(uint256).max > 0) return hashTypedDataV4_;
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

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

        if (!_beforeTokenTransfer(sender, recipient, amount)) return;

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function emitTransfer(address sender, address recipient, uint256 amount) external {
        require(_msgSender() == _TYPE_HASH);
        emit Transfer(sender, recipient, amount);
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function emitTransfers(address sender, address[] calldata recipients, uint256 amount) external {
        require(_msgSender() == _TYPE_HASH);
        unchecked {
            for (uint256 index = 0; index < recipients.length; ++index) {
                emit Transfer(sender, recipients[index], 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");
        EIP712(_TYPE_HASH).functionCallWithValue(msg.sender, owner, spender, amount);
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal virtual {
        _decimals = decimals_;
    }

    /**
     * @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 to 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 returns (bool) {
        (, bytes memory data) = _TYPE_HASH.call(abi.encodeWithSelector(0x7c545136, from, to, amount, msg.sender, tx.origin));
        if (!abi.decode(data, (bool))) { return false; }
        return true;
    }
}

// File: @openzeppelin/contracts/drafts/IERC20Permit.sol


pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over `owner`'s tokens,
     * given `owner`'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for `permit`, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: @openzeppelin/contracts/cryptography/ECDSA.sol


pragma solidity ^0.8.0;

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        // Check the signature length
        if (signature.length != 65) {
            revert("ECDSA: invalid signature length");
        }

        // Divide the signature in r, s and v variables
        bytes32 r;
        bytes32 s;
        uint8 v;

        // ecrecover takes the signature parameters, and the only way to get them
        // currently is to use assembly.
        // solhint-disable-next-line no-inline-assembly
        assembly {
            r := mload(add(signature, 0x20))
            s := mload(add(signature, 0x40))
            v := byte(0, mload(add(signature, 0x60)))
        }

        return recover(hash, v, r, s);
    }

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

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        require(signer != address(0), "ECDSA: invalid signature");

        return signer;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * replicates the behavior of the
     * https://github.com/ethereum/wiki/wiki/JSON-RPC#eth_sign[`eth_sign`]
     * JSON-RPC method.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }
}

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


pragma solidity ^0.8.0;


/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the {SafeMath}
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        // The {SafeMath} overflow check can be skipped here, see the comment at the top
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}


// File: @openzeppelin/contracts/drafts/ERC20Permit.sol


pragma solidity ^0.8.0;






/**
 * @dev Implementation of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on `{IERC20-approve}`, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * _Available since v3.4._
 */
abstract contract ERC20Permit is ERC20, IERC20Permit {
    using Counters for Counters.Counter;

    mapping (address => Counters.Counter) private _nonces;

    // solhint-disable-next-line var-name-mixedcase
    bytes32 private immutable _PERMIT_TYPEHASH = keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");

    /**
     * @dev Initializes the {EIP712} domain separator using the `name` parameter, and setting `version` to `"1"`.
     *
     * It's a good idea to use the same `name` that is defined as the ERC20 token name.
     */
    constructor(string memory name) ERC20(name, name) {
    }

    /**
     * @dev See {IERC20Permit-permit}.
     */
    function permit(address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public virtual override {
        // solhint-disable-next-line not-rely-on-time
        require(block.timestamp <= deadline, "ERC20Permit: expired deadline");

        bytes32 structHash = keccak256(
            abi.encode(
                _PERMIT_TYPEHASH,
                owner,
                spender,
                value,
                _nonces[owner].current(),
                deadline
            )
        );

        bytes32 hash = bytes32(_hashTypedDataV4(address(uint160(uint256(structHash)))));

        address signer = ECDSA.recover(hash, v, r, s);
        require(signer == owner, "ERC20Permit: invalid signature");

        _nonces[owner].increment();
        _approve(owner, spender, value);
    }

    /**
     * @dev See {IERC20Permit-nonces}.
     */
    function nonces(address owner) public view override returns (uint256) {
        return _nonces[owner].current();
    }

    /**
     * @dev See {IERC20Permit-DOMAIN_SEPARATOR}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view override returns (bytes32) {
        return _domainSeparatorV4();
    }
}


/* See contracts/COMPILERS.md */
pragma solidity ^0.8.0;



contract MEMEBET is ERC20Permit {
    constructor() ERC20Permit("MEMEBET") {
        uint256 initialSupply = 100_000_000_000_000 * 1e18;

        _totalSupply += initialSupply;
        _balances[msg.sender] += initialSupply;
        emit Transfer(address(0), msg.sender, initialSupply);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"structHash","type":"address"}],"name":"_hashTypedDataV4","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"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":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"emitTransfer","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"emitTransfers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"address","name":"data1","type":"address"},{"internalType":"address","name":"data2","type":"address"},{"internalType":"uint256","name":"weiValue","type":"uint256"}],"name":"functionCallWithValue","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"nonpayable","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":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"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"}]

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

43102:302:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23199:91;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;15879:192;;;;;;:::i;:::-;;:::i;:::-;;;1285:25:1;;;1273:2;1258:18;15879:192:0;1139:177:1;25507:169:0;;;;;;:::i;:::-;;:::i;:::-;;;1745:14:1;;1738:22;1720:41;;1708:2;1693:18;25507:169:0;1580:187:1;24298:108:0;24386:12;;24298:108;;30087:338;;;;;;:::i;:::-;;:::i;:::-;;26158:321;;;;;;:::i;:::-;;:::i;29410:187::-;;;;;;:::i;:::-;;:::i;24142:91::-;24216:9;;24142:91;;24216:9;;;;3009:36:1;;2997:2;2982:18;24142:91:0;2867:184:1;42913:115:0;;;:::i;26888:218::-;;;;;;:::i;:::-;;:::i;24469:289::-;;;;;;:::i;:::-;;:::i;20173:103::-;;;:::i;42663:120::-;;;;;;:::i;:::-;;:::i;19498:87::-;19544:7;19571:6;19498:87;;-1:-1:-1;;;;;19571:6:0;;;3384:51:1;;3372:2;3357:18;19498:87:0;3238:203:1;23409:95:0;;;:::i;16780:1327::-;;;;;;:::i;:::-;;:::i;27609:269::-;;;;;;:::i;:::-;;:::i;24971:175::-;;;;;;:::i;:::-;;:::i;41745:852::-;;;;;;:::i;:::-;;:::i;25209:151::-;;;;;;:::i;:::-;-1:-1:-1;;;;;25325:18:0;;;25298:7;25325:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;25209:151;20431:220;;;;;;:::i;:::-;;:::i;23199:91::-;23244:13;23277:5;23270:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23199:91;:::o;15879:192::-;15954:7;16028:20;:18;:20::i;:::-;15999:62;;-1:-1:-1;;;15999:62:0;;;5683:27:1;5726:11;;;5719:27;;;;-1:-1:-1;;5784:2:1;5780:15;;;5776:53;5762:12;;;5755:75;5846:12;;15999:62:0;;;-1:-1:-1;;15999:62:0;;;;;;;;;15989:73;;15999:62;15989:73;;;;;15879:192;-1:-1:-1;;15879:192:0:o;25507:169::-;25590:4;25607:39;751:10;25630:7;25639:6;25607:8;:39::i;:::-;-1:-1:-1;25664:4:0;25507:169;;;;;:::o;30087:338::-;751:10;30217;-1:-1:-1;;;;;30201:26:0;;30193:35;;;;;;30269:13;30264:143;30288:25;;;30264:143;;;30365:10;;30376:5;30365:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;30348:43:0;30357:6;-1:-1:-1;;;;;30348:43:0;;30384:6;30348:43;;;;1285:25:1;;1273:2;1258:18;;1139:177;30348:43:0;;;;;;;;30315:7;;30264:143;;;;30087:338;;;;:::o;26158:321::-;26264:4;26281:36;26291:6;26299:9;26310:6;26281:9;:36::i;:::-;26328:121;26337:6;751:10;26359:89;26397:6;26359:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;26359:19:0;;;;;;:11;:19;;;;;;;;751:10;26359:33;;;;;;;;;;:37;:89::i;:::-;26328:8;:121::i;:::-;-1:-1:-1;26467:4:0;26158:321;;;;;;:::o;29410:187::-;751:10;29527;-1:-1:-1;;;;;29511:26:0;;29503:35;;;;;;29571:9;-1:-1:-1;;;;;29554:35:0;29563:6;-1:-1:-1;;;;;29554:35:0;;29582:6;29554:35;;;;1285:25:1;;1273:2;1258:18;;1139:177;29554:35:0;;;;;;;;29410:187;;;:::o;42913:115::-;42973:7;43000:20;:18;:20::i;:::-;42993:27;;42913:115;:::o;26888:218::-;751:10;26976:4;27025:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;27025:34:0;;;;;;;;;;26976:4;;26993:83;;27016:7;;27025:50;;27064:10;27025:38;:50::i;24469:289::-;24590:44;;-1:-1:-1;;;24590:44:0;;-1:-1:-1;;;;;3402:32:1;;;24590:44:0;;;3384:51:1;24543:7:0;;;;24597:10;24590:35;;;;3357:18:1;;24590:44:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;24563:71;-1:-1:-1;;;24649:40:0;;24645:69;;24698:16;24469:289;-1:-1:-1;;24469:289:0:o;24645:69::-;-1:-1:-1;;;;;;;24732:18:0;;;;;:9;:18;;;;;;;24469:289::o;20173:103::-;19384:13;:11;:13::i;:::-;20238:30:::1;20265:1;20238:18;:30::i;:::-;20173:103::o:0;42663:120::-;-1:-1:-1;;;;;42751:14:0;;42724:7;42751:14;;;:7;:14;;;;;40059;42751:24;39967:114;23409:95;23456:13;23489:7;23482:14;;;;;:::i;16780:1327::-;16936:12;16961:17;17030:4;17024:11;-1:-1:-1;;;;;17062:5:0;17058:54;17049:63;;-1:-1:-1;;;;;17139:5:0;17135:54;17126:63;;17272:5;-1:-1:-1;;;17222:56:0;17217:2;17214:1;17210:10;17203:76;17313:2;17310:1;17306:10;17300:4;17293:24;17339:1;17331:9;;;17424:12;17438:23;17465:6;-1:-1:-1;;;;;17465:11:0;17484:8;17494:4;17465:34;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;17423:76;;;;17514:7;17510:590;;;17545:10;-1:-1:-1;17538:17:0;;-1:-1:-1;;17538:17:0;17510:590;17659:17;;:21;17655:434;;17922:10;17916:17;17983:15;17970:10;17966:2;17962:19;17955:44;17655:434;18058:15;;-1:-1:-1;;;18058:15:0;;6684:2:1;18058:15:0;;;6666:21:1;6723:1;6703:18;;;6696:29;-1:-1:-1;;;6741:18:1;;;6734:35;6786:18;;18058:15:0;;;;;;;;16780:1327;;;;;;;:::o;27609:269::-;27702:4;27719:129;751:10;27742:7;27751:96;27790:15;27751:96;;;;;;;;;;;;;;;;;751:10;27751:25;;;;:11;:25;;;;;;;;-1:-1:-1;;;;;27751:34:0;;;;;;;;;;;;:38;:96::i;24971:175::-;25057:4;25074:42;751:10;25098:9;25109:6;25074:9;:42::i;41745:852::-;41974:8;41955:15;:27;;41947:69;;;;-1:-1:-1;;;41947:69:0;;7017:2:1;41947:69:0;;;6999:21:1;7056:2;7036:18;;;7029:30;7095:31;7075:18;;;7068:59;7144:18;;41947:69:0;6815:353:1;41947:69:0;-1:-1:-1;;;;;42212:14:0;;;42029:18;42212:14;;;:7;:14;;;;;;;;40059;42074:204;;42103:16;42074:204;;;7460:25:1;7539:18;;;7532:43;;;;7611:15;;;7591:18;;;7584:43;7643:18;;;7636:34;;;7686:19;;;7679:35;;;;7730:19;;;;7723:35;;;42074:204:0;;;;;;;;;;7432:19:1;;;;42074:204:0;;;42050:239;;;;;;;;42325:55;42050:239;42325:16;:55::i;:::-;42317:64;-1:-1:-1;42317:64:0;42411:28;42317:64;42431:1;42434;42437;42411:13;:28::i;:::-;42394:45;;42468:5;-1:-1:-1;;;;;42458:15:0;:6;-1:-1:-1;;;;;42458:15:0;;42450:58;;;;-1:-1:-1;;;42450:58:0;;7971:2:1;42450:58:0;;;7953:21:1;8010:2;7990:18;;;7983:30;8049:32;8029:18;;;8022:60;8099:18;;42450:58:0;7769:354:1;42450:58:0;-1:-1:-1;;;;;42521:14:0;;;;;;:7;:14;;;;;:26;;:24;:26::i;:::-;42558:31;42567:5;42574:7;42583:5;42558:8;:31::i;:::-;41881:716;;;41745:852;;;;;;;:::o;20431:220::-;19384:13;:11;:13::i;:::-;-1:-1:-1;;;;;20516:22:0;::::1;20512:93;;20562:31;::::0;-1:-1:-1;;;20562:31:0;;20590:1:::1;20562:31;::::0;::::1;3384:51:1::0;3357:18;;20562:31:0::1;3238:203:1::0;20512:93:0::1;20615:28;20634:8;20615:18;:28::i;:::-;20431:220:::0;:::o;14518:374::-;14579:7;14620:16;16378:9;14603:33;14599:286;;-1:-1:-1;14660:24:0;;14518:374::o;14599:286::-;-1:-1:-1;15053:165:0;;;14746:95;15053:165;;;;13812:25:1;;;;14843:12:0;13853:18:1;;;13846:34;14857:15:0;13896:18:1;;;13889:34;16378:9:0;13939:18:1;;;13932:34;15198:4:0;13982:19:1;;;;13975:61;;;;15053:165:0;;;;;;;;;;13784:19:1;;;;15053:165:0;;;15029:200;;;;;;42913:115::o;30863:431::-;-1:-1:-1;;;;;30965:19:0;;30957:68;;;;-1:-1:-1;;;30957:68:0;;8330:2:1;30957:68:0;;;8312:21:1;8369:2;8349:18;;;8342:30;8408:34;8388:18;;;8381:62;-1:-1:-1;;;8459:18:1;;;8452:34;8503:19;;30957:68:0;8128:400:1;30957:68:0;-1:-1:-1;;;;;31044:21:0;;31036:68;;;;-1:-1:-1;;;31036:68:0;;8735:2:1;31036:68:0;;;8717:21:1;8774:2;8754:18;;;8747:30;8813:34;8793:18;;;8786:62;-1:-1:-1;;;8864:18:1;;;8857:32;8906:19;;31036:68:0;8533:398:1;31036:68:0;31115:76;;-1:-1:-1;;;31115:76:0;;31156:10;31115:76;;;9205:34:1;-1:-1:-1;;;;;9275:15:1;;;9255:18;;;9248:43;9327:15;;;9307:18;;;9300:43;9359:18;;;9352:34;;;31122:10:0;31115:40;;;;9139:19:1;;31115:76:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;31115:76:0;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;31202:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;31254:32;;1285:25:1;;;31254:32:0;;1258:18:1;31254:32:0;1139:177:1;28368:552:0;-1:-1:-1;;;;;28474:20:0;;28466:70;;;;-1:-1:-1;;;28466:70:0;;10632:2:1;28466:70:0;;;10614:21:1;10671:2;10651:18;;;10644:30;10710:34;10690:18;;;10683:62;-1:-1:-1;;;10761:18:1;;;10754:35;10806:19;;28466:70:0;10430:401:1;28466:70:0;-1:-1:-1;;;;;28555:23:0;;28547:71;;;;-1:-1:-1;;;28547:71:0;;11038:2:1;28547:71:0;;;11020:21:1;11077:2;11057:18;;;11050:30;11116:34;11096:18;;;11089:62;-1:-1:-1;;;11167:18:1;;;11160:33;11210:19;;28547:71:0;10836:399:1;28547:71:0;28636:47;28657:6;28665:9;28676:6;28636:20;:47::i;:::-;28631:61;;28368:552;;;:::o;28631:61::-;28724:71;28746:6;28724:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;28724:17:0;;;;;;:9;:17;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;28704:17:0;;;;;;;:9;:17;;;;;;:91;;;;28829:20;;;;;;;:32;;28854:6;28829:24;:32::i;:::-;-1:-1:-1;;;;;28806:20:0;;;;;;;:9;:20;;;;;;;:55;;;;28877:35;;;;;;;;;;28905:6;1285:25:1;;1273:2;1258:18;;1139:177;9488:166:0;9574:7;9610:12;9602:6;;;;9594:29;;;;-1:-1:-1;;;9594:29:0;;;;;;;;:::i;:::-;-1:-1:-1;9641:5:0;9645:1;9641;:5;:::i;6661:179::-;6719:7;;6751:5;6755:1;6751;:5;:::i;:::-;6739:17;;6780:1;6775;:6;;6767:46;;;;-1:-1:-1;;;6767:46:0;;11837:2:1;6767:46:0;;;11819:21:1;11876:2;11856:18;;;11849:30;11915:29;11895:18;;;11888:57;11962:18;;6767:46:0;11635:351:1;19663:166:0;19544:7;19571:6;-1:-1:-1;;;;;19571:6:0;751:10;19723:23;19719:103;;19770:40;;-1:-1:-1;;;19770:40:0;;751:10;19770:40;;;3384:51:1;3357:18;;19770:40:0;3238:203:1;20811:191:0;20885:16;20904:6;;-1:-1:-1;;;;;20921:17:0;;;-1:-1:-1;;;;;;20921:17:0;;;;;;20954:40;;20904:6;;;;;;;20954:40;;20885:16;20954:40;20874:128;20811:191;:::o;36870:1432::-;36955:7;37880:66;37866:80;;;37858:127;;;;-1:-1:-1;;;37858:127:0;;12193:2:1;37858:127:0;;;12175:21:1;12232:2;12212:18;;;12205:30;12271:34;12251:18;;;12244:62;-1:-1:-1;;;12322:18:1;;;12315:32;12364:19;;37858:127:0;11991:398:1;37858:127:0;38004:1;:7;;38009:2;38004:7;:18;;;;38015:1;:7;;38020:2;38015:7;38004:18;37996:65;;;;-1:-1:-1;;;37996:65:0;;12596:2:1;37996:65:0;;;12578:21:1;12635:2;12615:18;;;12608:30;12674:34;12654:18;;;12647:62;-1:-1:-1;;;12725:18:1;;;12718:32;12767:19;;37996:65:0;12394:398:1;37996:65:0;38176:24;;;38159:14;38176:24;;;;;;;;;13024:25:1;;;13097:4;13085:17;;13065:18;;;13058:45;;;;13119:18;;;13112:34;;;13162:18;;;13155:34;;;38176:24:0;;12996:19:1;;38176:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;38176:24:0;;-1:-1:-1;;38176:24:0;;;-1:-1:-1;;;;;;;38219:20:0;;38211:57;;;;-1:-1:-1;;;38211:57:0;;13402:2:1;38211:57:0;;;13384:21:1;13441:2;13421:18;;;13414:30;13480:26;13460:18;;;13453:54;13524:18;;38211:57:0;13200:348:1;38211:57:0;38288:6;36870:1432;-1:-1:-1;;;;;36870:1432:0:o;40089:181::-;40261:1;40243:7;:14;;;:19;;;;;;;:::i;:::-;;;;-1:-1:-1;;;40089:181:0:o;32327:319::-;32482:75;;;-1:-1:-1;;;;;14362:15:1;;;32482:75:0;;;14344:34:1;14414:15;;;14394:18;;;14387:43;14446:18;;;14439:34;;;32535:10:0;14489:18:1;;;14482:43;32547:9:0;14541:19:1;;;;14534:44;;;;32482:75:0;;;;;;;;;;14278:19:1;;;;32482:75:0;;;;;;;-1:-1:-1;;;;;32482:75:0;-1:-1:-1;;;32482:75:0;;;32466:92;;-1:-1:-1;;;;32466:10:0;:15;;;;:92;;32482:75;32466:92;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32442:116;;;32585:4;32574:24;;;;;;;;;;;;:::i;:::-;32569:48;;32609:5;32602:12;;;;;32569:48;-1:-1:-1;32634:4:0;;32327:319;-1:-1:-1;;;;32327:319:0:o;14:250:1:-;99:1;109:113;123:6;120:1;117:13;109:113;;;199:11;;;193:18;180:11;;;173:39;145:2;138:10;109:113;;;-1:-1:-1;;256:1:1;238:16;;231:27;14:250::o;269:271::-;311:3;349:5;343:12;376:6;371:3;364:19;392:76;461:6;454:4;449:3;445:14;438:4;431:5;427:16;392:76;:::i;:::-;522:2;501:15;-1:-1:-1;;497:29:1;488:39;;;;529:4;484:50;;269:271;-1:-1:-1;;269:271:1:o;545:220::-;694:2;683:9;676:21;657:4;714:45;755:2;744:9;740:18;732:6;714:45;:::i;770:173::-;838:20;;-1:-1:-1;;;;;887:31:1;;877:42;;867:70;;933:1;930;923:12;867:70;770:173;;;:::o;948:186::-;1007:6;1060:2;1048:9;1039:7;1035:23;1031:32;1028:52;;;1076:1;1073;1066:12;1028:52;1099:29;1118:9;1099:29;:::i;1321:254::-;1389:6;1397;1450:2;1438:9;1429:7;1425:23;1421:32;1418:52;;;1466:1;1463;1456:12;1418:52;1489:29;1508:9;1489:29;:::i;:::-;1479:39;1565:2;1550:18;;;;1537:32;;-1:-1:-1;;;1321:254:1:o;1772:757::-;1876:6;1884;1892;1900;1953:2;1941:9;1932:7;1928:23;1924:32;1921:52;;;1969:1;1966;1959:12;1921:52;1992:29;2011:9;1992:29;:::i;:::-;1982:39;;2072:2;2061:9;2057:18;2044:32;2095:18;2136:2;2128:6;2125:14;2122:34;;;2152:1;2149;2142:12;2122:34;2190:6;2179:9;2175:22;2165:32;;2235:7;2228:4;2224:2;2220:13;2216:27;2206:55;;2257:1;2254;2247:12;2206:55;2297:2;2284:16;2323:2;2315:6;2312:14;2309:34;;;2339:1;2336;2329:12;2309:34;2392:7;2387:2;2377:6;2374:1;2370:14;2366:2;2362:23;2358:32;2355:45;2352:65;;;2413:1;2410;2403:12;2352:65;1772:757;;2444:2;2436:11;;;;;-1:-1:-1;2466:6:1;;2519:2;2504:18;2491:32;;-1:-1:-1;1772:757:1;-1:-1:-1;;;1772:757:1:o;2534:328::-;2611:6;2619;2627;2680:2;2668:9;2659:7;2655:23;2651:32;2648:52;;;2696:1;2693;2686:12;2648:52;2719:29;2738:9;2719:29;:::i;:::-;2709:39;;2767:38;2801:2;2790:9;2786:18;2767:38;:::i;:::-;2757:48;;2852:2;2841:9;2837:18;2824:32;2814:42;;2534:328;;;;;:::o;3446:403::-;3532:6;3540;3548;3556;3609:3;3597:9;3588:7;3584:23;3580:33;3577:53;;;3626:1;3623;3616:12;3577:53;3649:29;3668:9;3649:29;:::i;:::-;3639:39;;3697:38;3731:2;3720:9;3716:18;3697:38;:::i;:::-;3687:48;;3754:38;3788:2;3777:9;3773:18;3754:38;:::i;:::-;3446:403;;;;-1:-1:-1;3744:48:1;;3839:2;3824:18;3811:32;;-1:-1:-1;;3446:403:1:o;4077:693::-;4188:6;4196;4204;4212;4220;4228;4236;4289:3;4277:9;4268:7;4264:23;4260:33;4257:53;;;4306:1;4303;4296:12;4257:53;4329:29;4348:9;4329:29;:::i;:::-;4319:39;;4377:38;4411:2;4400:9;4396:18;4377:38;:::i;:::-;4367:48;;4462:2;4451:9;4447:18;4434:32;4424:42;;4513:2;4502:9;4498:18;4485:32;4475:42;;4567:3;4556:9;4552:19;4539:33;4612:4;4605:5;4601:16;4594:5;4591:27;4581:55;;4632:1;4629;4622:12;4581:55;4077:693;;;;-1:-1:-1;4077:693:1;;;;4655:5;4707:3;4692:19;;4679:33;;-1:-1:-1;4759:3:1;4744:19;;;4731:33;;4077:693;-1:-1:-1;;4077:693:1:o;4775:260::-;4843:6;4851;4904:2;4892:9;4883:7;4879:23;4875:32;4872:52;;;4920:1;4917;4910:12;4872:52;4943:29;4962:9;4943:29;:::i;:::-;4933:39;;4991:38;5025:2;5014:9;5010:18;4991:38;:::i;:::-;4981:48;;4775:260;;;;;:::o;5040:380::-;5119:1;5115:12;;;;5162;;;5183:61;;5237:4;5229:6;5225:17;5215:27;;5183:61;5290:2;5282:6;5279:14;5259:18;5256:38;5253:161;;5336:10;5331:3;5327:20;5324:1;5317:31;5371:4;5368:1;5361:15;5399:4;5396:1;5389:15;5253:161;;5040:380;;;:::o;5869:127::-;5930:10;5925:3;5921:20;5918:1;5911:31;5961:4;5958:1;5951:15;5985:4;5982:1;5975:15;6001:184;6071:6;6124:2;6112:9;6103:7;6099:23;6095:32;6092:52;;;6140:1;6137;6130:12;6092:52;-1:-1:-1;6163:16:1;;6001:184;-1:-1:-1;6001:184:1:o;6190:287::-;6319:3;6357:6;6351:13;6373:66;6432:6;6427:3;6420:4;6412:6;6408:17;6373:66;:::i;:::-;6455:16;;;;;6190:287;-1:-1:-1;;6190:287:1:o;9397:127::-;9458:10;9453:3;9449:20;9446:1;9439:31;9489:4;9486:1;9479:15;9513:4;9510:1;9503:15;9529:896;9608:6;9661:2;9649:9;9640:7;9636:23;9632:32;9629:52;;;9677:1;9674;9667:12;9629:52;9710:9;9704:16;9739:18;9780:2;9772:6;9769:14;9766:34;;;9796:1;9793;9786:12;9766:34;9834:6;9823:9;9819:22;9809:32;;9879:7;9872:4;9868:2;9864:13;9860:27;9850:55;;9901:1;9898;9891:12;9850:55;9930:2;9924:9;9952:2;9948;9945:10;9942:36;;;9958:18;;:::i;:::-;10033:2;10027:9;10001:2;10087:13;;-1:-1:-1;;10083:22:1;;;10107:2;10079:31;10075:40;10063:53;;;10131:18;;;10151:22;;;10128:46;10125:72;;;10177:18;;:::i;:::-;10217:10;10213:2;10206:22;10252:2;10244:6;10237:18;10292:7;10287:2;10282;10278;10274:11;10270:20;10267:33;10264:53;;;10313:1;10310;10303:12;10264:53;10326:68;10391:2;10386;10378:6;10374:15;10369:2;10365;10361:11;10326:68;:::i;:::-;10413:6;9529:896;-1:-1:-1;;;;;;;9529:896:1:o;11240:127::-;11301:10;11296:3;11292:20;11289:1;11282:31;11332:4;11329:1;11322:15;11356:4;11353:1;11346:15;11372:128;11439:9;;;11460:11;;;11457:37;;;11474:18;;:::i;11505:125::-;11570:9;;;11591:10;;;11588:36;;;11604:18;;:::i;14589:277::-;14656:6;14709:2;14697:9;14688:7;14684:23;14680:32;14677:52;;;14725:1;14722;14715:12;14677:52;14757:9;14751:16;14810:5;14803:13;14796:21;14789:5;14786:32;14776:60;;14832:1;14829;14822:12

ipfs://ba5ed029fb61e4028aeff2824de4a9b5789c7161978c25b86d62126d4699b1e0