Token TokenPlay.app

 

Overview ERC-20

Price
$0.00 @ 0.000129 MATIC (-0.98%)
Fully Diluted Market Cap
Total Supply:
595,562,644.824118 TOP

Holders:
1,110 addresses

Transfers:
-

 
Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

OVERVIEW

Tokenplay is NFT & Gaming platform development on Binance Smart Chain and Polygon.


Update? Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
TokenPlayToken

Compiler Version
v0.8.6+commit.11564f7e

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.6;

interface IERC20 {
    /**
     * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `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 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);
}

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);
}

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

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}.
     *
     * 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_) {
        _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 value {ERC20} uses, unless this function is
     * 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:
     *
     * - `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);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - 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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

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

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, 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;
        _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;
        }
        _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 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 {}
}

abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        unchecked {
            _approve(account, _msgSender(), currentAllowance - amount);
        }
        _burn(account, amount);
    }
}

abstract contract Ownable is Context {
    address private _owner;

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

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

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

library SafeMath {

    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

contract TokenPlayToken is ERC20Burnable, Ownable {
    using SafeMath for uint256;

    uint256 public cap;
    mapping(address => uint256) public minterCap;

    uint256 private _totalBurned;

    /* ========== EVENTS ========== */

    event MinterCapUpdate(address indexed account, uint256 cap);

    /* ========== Modifiers =============== */

    modifier onlyMinter() {
        require(minterCap[msg.sender] > 0, "!minter");
        _;
    }

    /* ========== GOVERNANCE ========== */

    constructor() ERC20("TokenPlay.app", "TOP") {
        cap = 1000000000 ether; // Max Supply: 1 billion TOP
        _mint(_msgSender(), (cap * 13) / 100); // IDO + Team/Advisor: 13%
    }

    function setCap(uint256 _newCap) external onlyOwner {
        require(totalSupply() <= _newCap, "exceeds current supply");
        cap = _newCap;
    }

    function setMinterCap(address _account, uint256 _minterCap) external onlyOwner {
        require(_account != address(0), "zero");
        minterCap[_account] = _minterCap;
        emit MinterCapUpdate(_account, _minterCap);
    }

    /* ========== VIEW FUNCTIONS ========== */

    function totalBurned() external view returns (uint256) {
        return _totalBurned;
    }

    /* ========== MUTATIVE FUNCTIONS ========== */

    function mint(address _recipient, uint256 _amount) external onlyMinter returns (bool) {
        uint256 balanceBefore = balanceOf(_recipient);
        minterCap[_msgSender()] = minterCap[_msgSender()].sub(_amount, "minting amount exceeds minter cap");
        _mint(_recipient, _amount);
        return balanceOf(_recipient) > balanceBefore;
    }

    /* ========== OVERRIDE STANDARD FUNCTIONS ========== */

    /**
     * @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 override {
        super._burn(_account, _amount);
        _totalBurned = _totalBurned.add(_amount);
    }

    /**
     * @dev See {ERC20-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - minted tokens must not cause the total supply to go over the cap.
     */
    function _beforeTokenTransfer(
        address _from,
        address _to,
        uint256 _amount
    ) internal override {
        super._beforeTokenTransfer(_from, _to, _amount);
        if (_from == address(0)) {
            // When minting tokens
            require(totalSupply().add(_amount) <= cap, "cap exceeded");
        }
        if (_to == address(0)) {
            // When burning tokens
            cap = cap.sub(_amount, "burn amount exceeds cap");
        }
    }

    /* ========== EMERGENCY ========== */

    function rescueStuckErc20(address _token) external onlyOwner {
        IERC20(_token).transfer(owner(), IERC20(_token).balanceOf(address(this)));
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"cap","type":"uint256"}],"name":"MinterCapUpdate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"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":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cap","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":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minterCap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"rescueStuckErc20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCap","type":"uint256"}],"name":"setCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_minterCap","type":"uint256"}],"name":"setMinterCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalBurned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

23154:3132:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4183:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6350:169;;;;;;:::i;:::-;;:::i;:::-;;;2548:14:1;;2541:22;2523:41;;2511:2;2496:18;6350:169:0;2478:92:1;5303:108:0;5391:12;;5303:108;;;9860:25:1;;;9848:2;9833:18;5303:108:0;9815:76:1;7001:492:0;;;;;;:::i;:::-;;:::i;5145:93::-;;;5228:2;10038:36:1;;10026:2;10011:18;5145:93:0;9993:87:1;23246:18:0;;;;;;7902:215;;;;;;:::i;:::-;;:::i;24478:352::-;;;;;;:::i;:::-;;:::i;14309:91::-;;;;;;:::i;:::-;;:::i;:::-;;23870:154;;;;;;:::i;:::-;;:::i;23271:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;5474:127;;;;;;:::i;:::-;-1:-1:-1;;;;;5575:18:0;5548:7;5575:18;;;;;;;;;;;;5474:127;16148:94;;;:::i;14719:368::-;;;;;;:::i;:::-;;:::i;26130:153::-;;;;;;:::i;:::-;;:::i;15497:87::-;15570:6;;15497:87;;-1:-1:-1;;;;;15570:6:0;;;2042:51:1;;2030:2;2015:18;15497:87:0;1997:102:1;4402:104:0;;;:::i;8620:413::-;;;;;;:::i;:::-;;:::i;5814:175::-;;;;;;:::i;:::-;;:::i;24032:233::-;;;;;;:::i;:::-;;:::i;24323:93::-;24396:12;;24323:93;;6052:151;;;;;;:::i;:::-;-1:-1:-1;;;;;6168:18:0;;;6141:7;6168:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;6052:151;16397:192;;;;;;:::i;:::-;;:::i;4183:100::-;4237:13;4270:5;4263:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4183:100;:::o;6350:169::-;6433:4;6450:39;3269:10;6473:7;6482:6;6450:8;:39::i;:::-;-1:-1:-1;6507:4:0;6350:169;;;;:::o;7001:492::-;7141:4;7158:36;7168:6;7176:9;7187:6;7158:9;:36::i;:::-;-1:-1:-1;;;;;7234:19:0;;7207:24;7234:19;;;:11;:19;;;;;;;;3269:10;7234:33;;;;;;;;7286:26;;;;7278:79;;;;-1:-1:-1;;;7278:79:0;;6762:2:1;7278:79:0;;;6744:21:1;6801:2;6781:18;;;6774:30;6840:34;6820:18;;;6813:62;-1:-1:-1;;;6891:18:1;;;6884:38;6939:19;;7278:79:0;;;;;;;;;7393:57;7402:6;3269:10;7443:6;7424:16;:25;7393:8;:57::i;:::-;-1:-1:-1;7481:4:0;;7001:492;-1:-1:-1;;;;7001:492:0:o;7902:215::-;3269:10;7990:4;8039:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;8039:34:0;;;;;;;;;;7990:4;;8007:80;;8030:7;;8039:47;;8076:10;;8039:47;:::i;:::-;8007:8;:80::i;24478:352::-;23572:10;24558:4;23562:21;;;:9;:21;;;;;;23554:45;;;;-1:-1:-1;;;23554:45:0;;3379:2:1;23554:45:0;;;3361:21:1;3418:1;3398:18;;;3391:29;-1:-1:-1;;;3436:18:1;;;3429:37;3483:18;;23554:45:0;3351:156:1;23554:45:0;-1:-1:-1;;;;;5575:18:0;;24575:21:::1;5575:18:::0;;;;;;;;;;;24575:45:::1;;24657:73;24685:7;24657:73;;;;;;;;;;;;;;;;;3269:10:::0;24657:23:::1;::::0;;;:9:::1;:23;::::0;;;;;;;:27:::1;:73::i;:::-;3269:10:::0;24631:23:::1;::::0;;;:9:::1;:23;::::0;;;;:99;24741:26:::1;24747:10:::0;24759:7;24741:5:::1;:26::i;:::-;24809:13;24785:21;24795:10;-1:-1:-1::0;;;;;5575:18:0;5548:7;5575:18;;;;;;;;;;;;5474:127;24785:21:::1;:37;::::0;24478:352;-1:-1:-1;;;;24478:352:0:o;14309:91::-;14365:27;3269:10;14385:6;14365:5;:27::i;:::-;14309:91;:::o;23870:154::-;15570:6;;-1:-1:-1;;;;;15570:6:0;3269:10;15717:23;15709:68;;;;-1:-1:-1;;;15709:68:0;;;;;;;:::i;:::-;23958:7:::1;23941:13;5391:12:::0;;;5303:108;23941:13:::1;:24;;23933:59;;;::::0;-1:-1:-1;;;23933:59:0;;6411:2:1;23933:59:0::1;::::0;::::1;6393:21:1::0;6450:2;6430:18;;;6423:30;-1:-1:-1;;;6469:18:1;;;6462:52;6531:18;;23933:59:0::1;6383:172:1::0;23933:59:0::1;24003:3;:13:::0;23870:154::o;16148:94::-;15570:6;;-1:-1:-1;;;;;15570:6:0;3269:10;15717:23;15709:68;;;;-1:-1:-1;;;15709:68:0;;;;;;;:::i;:::-;16213:21:::1;16231:1;16213:9;:21::i;:::-;16148:94::o:0;14719:368::-;14796:24;14823:32;14833:7;3269:10;6052:151;:::i;14823:32::-;14796:59;;14894:6;14874:16;:26;;14866:75;;;;-1:-1:-1;;;14866:75:0;;7532:2:1;14866:75:0;;;7514:21:1;7571:2;7551:18;;;7544:30;7610:34;7590:18;;;7583:62;-1:-1:-1;;;7661:18:1;;;7654:34;7705:19;;14866:75:0;7504:226:1;14866:75:0;14977:58;14986:7;3269:10;15028:6;15009:16;:25;14977:8;:58::i;:::-;15057:22;15063:7;15072:6;15057:5;:22::i;:::-;14785:302;14719:368;;:::o;26130:153::-;15570:6;;-1:-1:-1;;;;;15570:6:0;3269:10;15717:23;15709:68;;;;-1:-1:-1;;;15709:68:0;;;;;;;:::i;:::-;26209:6:::1;-1:-1:-1::0;;;;;26202:23:0::1;;26226:7;15570:6:::0;;-1:-1:-1;;;;;15570:6:0;;15497:87;26226:7:::1;26235:39;::::0;-1:-1:-1;;;26235:39:0;;26268:4:::1;26235:39;::::0;::::1;2042:51:1::0;-1:-1:-1;;;;;26235:24:0;::::1;::::0;::::1;::::0;2015:18:1;;26235:39:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26202:73;::::0;-1:-1:-1;;;;;;26202:73:0::1;::::0;;;;;;-1:-1:-1;;;;;2296:32:1;;;26202:73:0::1;::::0;::::1;2278:51:1::0;2345:18;;;2338:34;2251:18;;26202:73:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;26130:153:::0;:::o;4402:104::-;4458:13;4491:7;4484:14;;;;;:::i;8620:413::-;3269:10;8713:4;8757:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;8757:34:0;;;;;;;;;;8810:35;;;;8802:85;;;;-1:-1:-1;;;8802:85:0;;9150:2:1;8802:85:0;;;9132:21:1;9189:2;9169:18;;;9162:30;9228:34;9208:18;;;9201:62;-1:-1:-1;;;9279:18:1;;;9272:35;9324:19;;8802:85:0;9122:227:1;8802:85:0;8923:67;3269:10;8946:7;8974:15;8955:16;:34;8923:8;:67::i;:::-;-1:-1:-1;9021:4:0;;8620:413;-1:-1:-1;;;8620:413:0:o;5814:175::-;5900:4;5917:42;3269:10;5941:9;5952:6;5917:9;:42::i;24032:233::-;15570:6;;-1:-1:-1;;;;;15570:6:0;3269:10;15717:23;15709:68;;;;-1:-1:-1;;;15709:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;24130:22:0;::::1;24122:39;;;;-1:-1:-1::0;;;24122:39:0::1;;;;;;5331:2:1::0;5313:21;;;5370:1;5350:18;;;5343:29;-1:-1:-1;;;5403:2:1;5388:18;;5381:34;5447:2;5432:18;;5303:153;24122:39:0::1;-1:-1:-1::0;;;;;24172:19:0;::::1;;::::0;;;:9:::1;:19;::::0;;;;;;:32;;;24220:37;::::1;::::0;::::1;::::0;24194:10;9860:25:1;;9848:2;9833:18;;9815:76;24220:37:0::1;;;;;;;;24032:233:::0;;:::o;16397:192::-;15570:6;;-1:-1:-1;;;;;15570:6:0;3269:10;15717:23;15709:68;;;;-1:-1:-1;;;15709:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;16486:22:0;::::1;16478:73;;;::::0;-1:-1:-1;;;16478:73:0;;4521:2:1;16478:73:0::1;::::0;::::1;4503:21:1::0;4560:2;4540:18;;;4533:30;4599:34;4579:18;;;4572:62;-1:-1:-1;;;4650:18:1;;;4643:36;4696:19;;16478:73:0::1;4493:228:1::0;16478:73:0::1;16562:19;16572:8;16562:9;:19::i;18989:98::-:0;19047:7;19074:5;19078:1;19074;:5;:::i;:::-;19067:12;18989:98;-1:-1:-1;;;18989:98:0:o;21268:240::-;21388:7;21449:12;21441:6;;;;21433:29;;;;-1:-1:-1;;;21433:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;21484:5:0;;;21268:240::o;12304:380::-;-1:-1:-1;;;;;12440:19:0;;12432:68;;;;-1:-1:-1;;;12432:68:0;;8745:2:1;12432:68:0;;;8727:21:1;8784:2;8764:18;;;8757:30;8823:34;8803:18;;;8796:62;-1:-1:-1;;;8874:18:1;;;8867:34;8918:19;;12432:68:0;8717:226:1;12432:68:0;-1:-1:-1;;;;;12519:21:0;;12511:68;;;;-1:-1:-1;;;12511:68:0;;4928:2:1;12511:68:0;;;4910:21:1;4967:2;4947:18;;;4940:30;5006:34;4986:18;;;4979:62;-1:-1:-1;;;5057:18:1;;;5050:32;5099:19;;12511:68:0;4900:224:1;12511:68:0;-1:-1:-1;;;;;12592:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;12644:32;;9860:25:1;;;12644:32:0;;9833:18:1;12644:32:0;;;;;;;12304:380;;;:::o;9523:733::-;-1:-1:-1;;;;;9663:20:0;;9655:70;;;;-1:-1:-1;;;9655:70:0;;8339:2:1;9655:70:0;;;8321:21:1;8378:2;8358:18;;;8351:30;8417:34;8397:18;;;8390:62;-1:-1:-1;;;8468:18:1;;;8461:35;8513:19;;9655:70:0;8311:227:1;9655:70:0;-1:-1:-1;;;;;9744:23:0;;9736:71;;;;-1:-1:-1;;;9736:71:0;;3714:2:1;9736:71:0;;;3696:21:1;3753:2;3733:18;;;3726:30;3792:34;3772:18;;;3765:62;-1:-1:-1;;;3843:18:1;;;3836:33;3886:19;;9736:71:0;3686:225:1;9736:71:0;9820:47;9841:6;9849:9;9860:6;9820:20;:47::i;:::-;-1:-1:-1;;;;;9904:17:0;;9880:21;9904:17;;;;;;;;;;;9940:23;;;;9932:74;;;;-1:-1:-1;;;9932:74:0;;6004:2:1;9932:74:0;;;5986:21:1;6043:2;6023:18;;;6016:30;6082:34;6062:18;;;6055:62;-1:-1:-1;;;6133:18:1;;;6126:36;6179:19;;9932:74:0;5976:228:1;9932:74:0;-1:-1:-1;;;;;10042:17:0;;;:9;:17;;;;;;;;;;;10062:22;;;10042:42;;10106:20;;;;;;;;:30;;10078:6;;10042:9;10106:30;;10078:6;;10106:30;:::i;:::-;;;;;;;;10171:9;-1:-1:-1;;;;;10154:35:0;10163:6;-1:-1:-1;;;;;10154:35:0;;10182:6;10154:35;;;;9860:25:1;;9848:2;9833:18;;9815:76;10154:35:0;;;;;;;;9644:612;9523:733;;;:::o;10543:399::-;-1:-1:-1;;;;;10627:21:0;;10619:65;;;;-1:-1:-1;;;10619:65:0;;9556:2:1;10619:65:0;;;9538:21:1;9595:2;9575:18;;;9568:30;9634:33;9614:18;;;9607:61;9685:18;;10619:65:0;9528:181:1;10619:65:0;10697:49;10726:1;10730:7;10739:6;10697:20;:49::i;:::-;10775:6;10759:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;10792:18:0;;:9;:18;;;;;;;;;;:28;;10814:6;;10792:9;:28;;10814:6;;10792:28;:::i;:::-;;;;-1:-1:-1;;10836:37:0;;9860:25:1;;;-1:-1:-1;;;;;10836:37:0;;;10853:1;;10836:37;;9848:2:1;9833:18;10836:37:0;;;;;;;26202:73:::1;26130:153:::0;:::o;25228:168::-;25307:30;25319:8;25329:7;25307:11;:30::i;:::-;25363:12;;:25;;25380:7;25363:16;:25::i;:::-;25348:12;:40;-1:-1:-1;;25228:168:0:o;16597:173::-;16672:6;;;-1:-1:-1;;;;;16689:17:0;;;-1:-1:-1;;;;;;16689:17:0;;;;;;;16722:40;;16672:6;;;16689:17;16672:6;;16722:40;;16653:16;;16722:40;16642:128;16597:173;:::o;25583:494::-;-1:-1:-1;;;;;25783:19:0;;25779:146;;25893:3;;25863:26;25881:7;25863:13;5391:12;;;5303:108;25863:13;:17;;:26::i;:::-;:33;;25855:58;;;;-1:-1:-1;;;25855:58:0;;5663:2:1;25855:58:0;;;5645:21:1;5702:2;5682:18;;;5675:30;-1:-1:-1;;;5721:18:1;;;5714:42;5773:18;;25855:58:0;5635:162:1;25855:58:0;-1:-1:-1;;;;;25939:17:0;;25935:135;;26015:43;;;;;;;;;;;;;;;;;:3;;:43;;26023:7;;26015;:43::i;:::-;26009:3;:49;25583:494;;;:::o;11275:591::-;-1:-1:-1;;;;;11359:21:0;;11351:67;;;;-1:-1:-1;;;11351:67:0;;7937:2:1;11351:67:0;;;7919:21:1;7976:2;7956:18;;;7949:30;8015:34;7995:18;;;7988:62;-1:-1:-1;;;8066:18:1;;;8059:31;8107:19;;11351:67:0;7909:223:1;11351:67:0;11431:49;11452:7;11469:1;11473:6;11431:20;:49::i;:::-;-1:-1:-1;;;;;11518:18:0;;11493:22;11518:18;;;;;;;;;;;11555:24;;;;11547:71;;;;-1:-1:-1;;;11547:71:0;;4118:2:1;11547:71:0;;;4100:21:1;4157:2;4137:18;;;4130:30;4196:34;4176:18;;;4169:62;-1:-1:-1;;;4247:18:1;;;4240:32;4289:19;;11547:71:0;4090:224:1;11547:71:0;-1:-1:-1;;;;;11654:18:0;;:9;:18;;;;;;;;;;11675:23;;;11654:44;;11720:12;:22;;11692:6;;11654:9;11720:22;;11692:6;;11720:22;:::i;:::-;;;;-1:-1:-1;;11760:37:0;;9860:25:1;;;11786:1:0;;-1:-1:-1;;;;;11760:37:0;;;;;9848:2:1;9833:18;11760:37:0;;;;;;;14785:302;14719:368;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:2;;;320:1;317;310:12;272:2;343:29;362:9;343:29;:::i;383:260::-;451:6;459;512:2;500:9;491:7;487:23;483:32;480:2;;;528:1;525;518:12;480:2;551:29;570:9;551:29;:::i;:::-;541:39;;599:38;633:2;622:9;618:18;599:38;:::i;:::-;589:48;;470:173;;;;;:::o;648:328::-;725:6;733;741;794:2;782:9;773:7;769:23;765:32;762:2;;;810:1;807;800:12;762:2;833:29;852:9;833:29;:::i;:::-;823:39;;881:38;915:2;904:9;900:18;881:38;:::i;:::-;871:48;;966:2;955:9;951:18;938:32;928:42;;752:224;;;;;:::o;981:254::-;1049:6;1057;1110:2;1098:9;1089:7;1085:23;1081:32;1078:2;;;1126:1;1123;1116:12;1078:2;1149:29;1168:9;1149:29;:::i;:::-;1139:39;1225:2;1210:18;;;;1197:32;;-1:-1:-1;;;1068:167:1:o;1240:277::-;1307:6;1360:2;1348:9;1339:7;1335:23;1331:32;1328:2;;;1376:1;1373;1366:12;1328:2;1408:9;1402:16;1461:5;1454:13;1447:21;1440:5;1437:32;1427:2;;1483:1;1480;1473:12;1522:180;1581:6;1634:2;1622:9;1613:7;1609:23;1605:32;1602:2;;;1650:1;1647;1640:12;1602:2;-1:-1:-1;1673:23:1;;1592:110;-1:-1:-1;1592:110:1:o;1707:184::-;1777:6;1830:2;1818:9;1809:7;1805:23;1801:32;1798:2;;;1846:1;1843;1836:12;1798:2;-1:-1:-1;1869:16:1;;1788:103;-1:-1:-1;1788:103:1:o;2575:597::-;2687:4;2716:2;2745;2734:9;2727:21;2777:6;2771:13;2820:6;2815:2;2804:9;2800:18;2793:34;2845:1;2855:140;2869:6;2866:1;2863:13;2855:140;;;2964:14;;;2960:23;;2954:30;2930:17;;;2949:2;2926:26;2919:66;2884:10;;2855:140;;;3013:6;3010:1;3007:13;3004:2;;;3083:1;3078:2;3069:6;3058:9;3054:22;3050:31;3043:42;3004:2;-1:-1:-1;3156:2:1;3135:15;-1:-1:-1;;3131:29:1;3116:45;;;;3163:2;3112:54;;2696:476;-1:-1:-1;;;2696:476:1:o;6969:356::-;7171:2;7153:21;;;7190:18;;;7183:30;7249:34;7244:2;7229:18;;7222:62;7316:2;7301:18;;7143:182::o;10085:128::-;10125:3;10156:1;10152:6;10149:1;10146:13;10143:2;;;10162:18;;:::i;:::-;-1:-1:-1;10198:9:1;;10133:80::o;10218:125::-;10258:4;10286:1;10283;10280:8;10277:2;;;10291:18;;:::i;:::-;-1:-1:-1;10328:9:1;;10267:76::o;10348:380::-;10427:1;10423:12;;;;10470;;;10491:2;;10545:4;10537:6;10533:17;10523:27;;10491:2;10598;10590:6;10587:14;10567:18;10564:38;10561:2;;;10644:10;10639:3;10635:20;10632:1;10625:31;10679:4;10676:1;10669:15;10707:4;10704:1;10697:15;10561:2;;10403:325;;;:::o;10733:127::-;10794:10;10789:3;10785:20;10782:1;10775:31;10825:4;10822:1;10815:15;10849:4;10846:1;10839:15

Swarm Source

ipfs://775e2b40a61ba3ac2204c801e1777f3e0aa410d42e04f24f257b4ebcd00d0735
Loading