Token GCOIN

Gaming 
 

Overview ERC-20

Price
$0.04 @ 0.033592 MATIC (-10.86%)
Fully Diluted Market Cap
Total Supply:
148,799,486.699056 GFC

Holders:
7,126 addresses

Transfers:
-

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

OVERVIEW

Galaxy Fight Club is building a cross-IP PvP game for the NFT Universe. A real-time PvP game to bring together all the other different NFT collections onto one single platform.

Market

Volume (24H):$16,577.41
Market Capitalization:$593,851.68
Circulating Supply:14,384,463.00 GFC
Market Data Source: Coinmarketcap


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:
GCOIN

Compiler Version
v0.8.11+commit.d7f03943

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity Multiple files format)

File 6 of 11: GCOIN.sol
// SPDX-License-Identifier: MIT
   
pragma solidity 0.8.11;

import "./ERC20Burnable.sol";
import "./Ownable.sol";
import "./MintOwnable.sol";

contract GCOIN is MintOwnable, Ownable, ERC20Burnable {

    uint256 public constant TOKEN_MAX_CAP = 150_000_000*1e18; // 150 million * 10^18

    constructor() ERC20('GCOIN', 'GFC') {
        _mint(msg.sender, TOKEN_MAX_CAP);
    }

    function pause() external onlyOwner {
        _pause();
    }

    function unpause() external onlyOwner {
        _unpause();
    }

    function mint(address to, uint256 amount) public onlyMinter {
        require(totalSupply() + amount <= TOKEN_MAX_CAP, "Exceeded TOKEN_MAX_CAP");
        _mint(to, amount);
    }
}

File 1 of 11: Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

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

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

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

File 2 of 11: Context.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

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

File 3 of 11: ERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * 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 {}
}

File 4 of 11: ERC20Burnable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";
import "./ERC20Pausable.sol";

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20Pausable {
    /**
     * @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);
    }
}

File 5 of 11: ERC20Pausable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./ERC20.sol";
import "./Pausable.sol";

/**
 * @dev ERC20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract ERC20Pausable is ERC20, Pausable {
    /**
     * @dev See {ERC20-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        require(!paused(), "ERC20Pausable: token transfer while paused");
    }
}

File 7 of 11: IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
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);
}

File 8 of 11: IERC20Metadata.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./IERC20.sol";

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

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

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

File 9 of 11: MintOwnable.sol
// SPDX-License-Identifier: MIT
   
pragma solidity ^0.8.11;

contract MintOwnable {
    address public minter;

    event MinterSet(address minter);

    constructor() { 
        minter = msg.sender; 
    }

    modifier onlyMinter {
        require(msg.sender == minter, "You are not authorizated to call this function");
        _;
    }

    function setMinter(address address_) external onlyMinter {
        require(address_ != address(0x0), "the minter can not be set to the burn address");
        minter = address_;

        emit MinterSet(minter);
    }

    function renounceMinter() external onlyMinter {
        minter = address(0x0);
    }
}

File 10 of 11: Ownable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _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);
    }
}

File 11 of 11: Pausable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

import "./Context.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

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":false,"internalType":"address","name":"minter","type":"address"}],"name":"MinterSet","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"TOKEN_MAX_CAP","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":[{"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":"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":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"address_","type":"address"}],"name":"setMinter","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"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

144:556:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2063:98:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;89:21:8;;;;;-1:-1:-1;;;;;89:21:8;;;;;;-1:-1:-1;;;;;780:32:11;;;762:51;;750:2;735:18;89:21:8;616:203:11;4160:166:2;;;;;;:::i;:::-;;:::i;:::-;;;1426:14:11;;1419:22;1401:41;;1389:2;1374:18;4160:166:2;1261:187:11;3151:106:2;3238:12;;3151:106;;;1599:25:11;;;1587:2;1572:18;3151:106:2;1453:177:11;4793:478:2;;;;;;:::i;:::-;;:::i;3000:91::-;;;3082:2;2110:36:11;;2098:2;2083:18;3000:91:2;1968:184:11;5666:212:2;;;;;;:::i;:::-;;:::i;449:65:5:-;;;:::i;:::-;;520:178;;;;;;:::i;:::-;;:::i;489:89:3:-;;;;;;:::i;:::-;;:::i;1034:84:10:-;1104:7;;;;1034:84;;3315:125:2;;;;;;:::i;:::-;-1:-1:-1;;;;;3415:18:2;3389:7;3415:18;;;:9;:18;;;;;;;3315:125;1598:92:9;;;:::i;884:361:3:-;;;;;;:::i;:::-;;:::i;382:61:5:-;;;:::i;205:56::-;;245:16;205:56;;966:85:9;1038:6;;-1:-1:-1;;;;;1038:6:9;966:85;;2274:102:2;;;:::i;568:84:8:-;;;:::i;6365:405:2:-;;;;;;:::i;:::-;;:::i;3643:172::-;;;;;;:::i;:::-;;:::i;3873:149::-;;;;;;:::i;:::-;-1:-1:-1;;;;;3988:18:2;;;3962:7;3988:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;3873:149;1839:189:9;;;;;;:::i;:::-;;:::i;346:216:8:-;;;;;;:::i;:::-;;:::i;2063:98:2:-;2117:13;2149:5;2142:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2063:98;:::o;4160:166::-;4243:4;4259:39;666:10:1;4282:7:2;4291:6;4259:8;:39::i;:::-;-1:-1:-1;4315:4:2;4160:166;;;;:::o;4793:478::-;4929:4;4945:36;4955:6;4963:9;4974:6;4945:9;:36::i;:::-;-1:-1:-1;;;;;5019:19:2;;4992:24;5019:19;;;:11;:19;;;;;;;;666:10:1;5019:33:2;;;;;;;;5070:26;;;;5062:79;;;;-1:-1:-1;;;5062:79:2;;3385:2:11;5062:79:2;;;3367:21:11;3424:2;3404:18;;;3397:30;3463:34;3443:18;;;3436:62;-1:-1:-1;;;3514:18:11;;;3507:38;3562:19;;5062:79:2;;;;;;;;;5175:57;5184:6;666:10:1;5225:6:2;5206:16;:25;5175:8;:57::i;:::-;-1:-1:-1;5260:4:2;;4793:478;-1:-1:-1;;;;4793:478:2:o;5666:212::-;666:10:1;5754:4:2;5802:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;5802:34:2;;;;;;;;;;5754:4;;5770:80;;5793:7;;5802:47;;5839:10;;5802:47;:::i;:::-;5770:8;:80::i;449:65:5:-;1038:6:9;;-1:-1:-1;;;;;1038:6:9;666:10:1;1178:23:9;1170:68;;;;-1:-1:-1;;;1170:68:9;;;;;;;:::i;:::-;497:10:5::1;:8;:10::i;:::-;449:65::o:0;520:178::-;265:6:8;;-1:-1:-1;;;;;265:6:8;251:10;:20;243:79;;;;-1:-1:-1;;;243:79:8;;;;;;;:::i;:::-;245:16:5::1;614:6;598:13;3238:12:2::0;;;3151:106;598:13:5::1;:22;;;;:::i;:::-;:39;;590:74;;;::::0;-1:-1:-1;;;590:74:5;;4835:2:11;590:74:5::1;::::0;::::1;4817:21:11::0;4874:2;4854:18;;;4847:30;-1:-1:-1;;;4893:18:11;;;4886:52;4955:18;;590:74:5::1;4633:346:11::0;590:74:5::1;674:17;680:2;684:6;674:5;:17::i;:::-;520:178:::0;;:::o;489:89:3:-;544:27;666:10:1;564:6:3;544:5;:27::i;:::-;489:89;:::o;1598:92:9:-;1038:6;;-1:-1:-1;;;;;1038:6:9;666:10:1;1178:23:9;1170:68;;;;-1:-1:-1;;;1170:68:9;;;;;;;:::i;:::-;1662:21:::1;1680:1;1662:9;:21::i;884:361:3:-:0;960:24;987:32;997:7;666:10:1;3873:149:2;:::i;987:32:3:-;960:59;;1057:6;1037:16;:26;;1029:75;;;;-1:-1:-1;;;1029:75:3;;5186:2:11;1029:75:3;;;5168:21:11;5225:2;5205:18;;;5198:30;5264:34;5244:18;;;5237:62;-1:-1:-1;;;5315:18:11;;;5308:34;5359:19;;1029:75:3;4984:400:11;1029:75:3;1138:58;1147:7;666:10:1;1189:6:3;1170:16;:25;1138:8;:58::i;:::-;1216:22;1222:7;1231:6;1216:5;:22::i;:::-;950:295;884:361;;:::o;382:61:5:-;1038:6:9;;-1:-1:-1;;;;;1038:6:9;666:10:1;1178:23:9;1170:68;;;;-1:-1:-1;;;1170:68:9;;;;;;;:::i;:::-;428:8:5::1;:6;:8::i;2274:102:2:-:0;2330:13;2362:7;2355:14;;;;;:::i;568:84:8:-;265:6;;-1:-1:-1;;;;;265:6:8;251:10;:20;243:79;;;;-1:-1:-1;;;243:79:8;;;;;;;:::i;:::-;641:3:::1;624:21:::0;;-1:-1:-1;;;;;;624:21:8::1;::::0;;568:84::o;6365:405:2:-;666:10:1;6458:4:2;6501:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;6501:34:2;;;;;;;;;;6553:35;;;;6545:85;;;;-1:-1:-1;;;6545:85:2;;5591:2:11;6545:85:2;;;5573:21:11;5630:2;5610:18;;;5603:30;5669:34;5649:18;;;5642:62;-1:-1:-1;;;5720:18:11;;;5713:35;5765:19;;6545:85:2;5389:401:11;6545:85:2;6664:67;666:10:1;6687:7:2;6715:15;6696:16;:34;6664:8;:67::i;:::-;-1:-1:-1;6759:4:2;;6365:405;-1:-1:-1;;;6365:405:2:o;3643:172::-;3729:4;3745:42;666:10:1;3769:9:2;3780:6;3745:9;:42::i;1839:189:9:-;1038:6;;-1:-1:-1;;;;;1038:6:9;666:10:1;1178:23:9;1170:68;;;;-1:-1:-1;;;1170:68:9;;;;;;;:::i;:::-;-1:-1:-1;;;;;1927:22:9;::::1;1919:73;;;::::0;-1:-1:-1;;;1919:73:9;;5997:2:11;1919:73:9::1;::::0;::::1;5979:21:11::0;6036:2;6016:18;;;6009:30;6075:34;6055:18;;;6048:62;-1:-1:-1;;;6126:18:11;;;6119:36;6172:19;;1919:73:9::1;5795:402:11::0;1919:73:9::1;2002:19;2012:8;2002:9;:19::i;346:216:8:-:0;265:6;;-1:-1:-1;;;;;265:6:8;251:10;:20;243:79;;;;-1:-1:-1;;;243:79:8;;;;;;;:::i;:::-;-1:-1:-1;;;;;421:24:8;::::1;413:82;;;::::0;-1:-1:-1;;;413:82:8;;6404:2:11;413:82:8::1;::::0;::::1;6386:21:11::0;6443:2;6423:18;;;6416:30;6482:34;6462:18;;;6455:62;-1:-1:-1;;;6533:18:11;;;6526:43;6586:19;;413:82:8::1;6202:409:11::0;413:82:8::1;505:6;:17:::0;;-1:-1:-1;;;;;;505:17:8::1;-1:-1:-1::0;;;;;505:17:8;::::1;::::0;;::::1;::::0;;;538::::1;::::0;762:51:11;;;538:17:8::1;::::0;750:2:11;735:18;538:17:8::1;;;;;;;346:216:::0;:::o;9941:370:2:-;-1:-1:-1;;;;;10072:19:2;;10064:68;;;;-1:-1:-1;;;10064:68:2;;6818:2:11;10064:68:2;;;6800:21:11;6857:2;6837:18;;;6830:30;6896:34;6876:18;;;6869:62;-1:-1:-1;;;6947:18:11;;;6940:34;6991:19;;10064:68:2;6616:400:11;10064:68:2;-1:-1:-1;;;;;10150:21:2;;10142:68;;;;-1:-1:-1;;;10142:68:2;;7223:2:11;10142:68:2;;;7205:21:11;7262:2;7242:18;;;7235:30;7301:34;7281:18;;;7274:62;-1:-1:-1;;;7352:18:11;;;7345:32;7394:19;;10142:68:2;7021:398:11;10142:68:2;-1:-1:-1;;;;;10221:18:2;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;10272:32;;1599:25:11;;;10272:32:2;;1572:18:11;10272:32:2;;;;;;;9941:370;;;:::o;7244:713::-;-1:-1:-1;;;;;7379:20:2;;7371:70;;;;-1:-1:-1;;;7371:70:2;;7626:2:11;7371:70:2;;;7608:21:11;7665:2;7645:18;;;7638:30;7704:34;7684:18;;;7677:62;-1:-1:-1;;;7755:18:11;;;7748:35;7800:19;;7371:70:2;7424:401:11;7371:70:2;-1:-1:-1;;;;;7459:23:2;;7451:71;;;;-1:-1:-1;;;7451:71:2;;8032:2:11;7451:71:2;;;8014:21:11;8071:2;8051:18;;;8044:30;8110:34;8090:18;;;8083:62;-1:-1:-1;;;8161:18:11;;;8154:33;8204:19;;7451:71:2;7830:399:11;7451:71:2;7533:47;7554:6;7562:9;7573:6;7533:20;:47::i;:::-;-1:-1:-1;;;;;7615:17:2;;7591:21;7615:17;;;:9;:17;;;;;;7650:23;;;;7642:74;;;;-1:-1:-1;;;7642:74:2;;8436:2:11;7642:74:2;;;8418:21:11;8475:2;8455:18;;;8448:30;8514:34;8494:18;;;8487:62;-1:-1:-1;;;8565:18:11;;;8558:36;8611:19;;7642:74:2;8234:402:11;7642:74:2;-1:-1:-1;;;;;7750:17:2;;;;;;;:9;:17;;;;;;7770:22;;;7750:42;;7812:20;;;;;;;;:30;;7786:6;;7750:17;7812:30;;7786:6;;7812:30;:::i;:::-;;;;;;;;7875:9;-1:-1:-1;;;;;7858:35:2;7867:6;-1:-1:-1;;;;;7858:35:2;;7886:6;7858:35;;;;1599:25:11;;1587:2;1572:18;;1453:177;7858:35:2;;;;;;;;7361:596;7244:713;;;:::o;2046:117:10:-;1104:7;;;;1605:41;;;;-1:-1:-1;;;1605:41:10;;8843:2:11;1605:41:10;;;8825:21:11;8882:2;8862:18;;;8855:30;-1:-1:-1;;;8901:18:11;;;8894:50;8961:18;;1605:41:10;8641:344:11;1605:41:10;2104:7:::1;:15:::0;;-1:-1:-1;;2104:15:10::1;::::0;;2134:22:::1;666:10:1::0;2143:12:10::1;2134:22;::::0;-1:-1:-1;;;;;780:32:11;;;762:51;;750:2;735:18;2134:22:10::1;;;;;;;2046:117::o:0;8233:389:2:-;-1:-1:-1;;;;;8316:21:2;;8308:65;;;;-1:-1:-1;;;8308:65:2;;9192:2:11;8308:65:2;;;9174:21:11;9231:2;9211:18;;;9204:30;9270:33;9250:18;;;9243:61;9321:18;;8308:65:2;8990:355:11;8308:65:2;8384:49;8413:1;8417:7;8426:6;8384:20;:49::i;:::-;8460:6;8444:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;8476:18:2;;;;;;:9;:18;;;;;:28;;8498:6;;8476:18;:28;;8498:6;;8476:28;:::i;:::-;;;;-1:-1:-1;;8519:37:2;;1599:25:11;;;-1:-1:-1;;;;;8519:37:2;;;8536:1;;8519:37;;1587:2:11;1572:18;8519:37:2;;;;;;;520:178:5;;:::o;8942:576:2:-;-1:-1:-1;;;;;9025:21:2;;9017:67;;;;-1:-1:-1;;;9017:67:2;;9552:2:11;9017:67:2;;;9534:21:11;9591:2;9571:18;;;9564:30;9630:34;9610:18;;;9603:62;-1:-1:-1;;;9681:18:11;;;9674:31;9722:19;;9017:67:2;9350:397:11;9017:67:2;9095:49;9116:7;9133:1;9137:6;9095:20;:49::i;:::-;-1:-1:-1;;;;;9180:18:2;;9155:22;9180:18;;;:9;:18;;;;;;9216:24;;;;9208:71;;;;-1:-1:-1;;;9208:71:2;;9954:2:11;9208:71:2;;;9936:21:11;9993:2;9973:18;;;9966:30;10032:34;10012:18;;;10005:62;-1:-1:-1;;;10083:18:11;;;10076:32;10125:19;;9208:71:2;9752:398:11;9208:71:2;-1:-1:-1;;;;;9313:18:2;;;;;;:9;:18;;;;;9334:23;;;9313:44;;9377:12;:22;;9351:6;;9313:18;9377:22;;9351:6;;9377:22;:::i;:::-;;;;-1:-1:-1;;9415:37:2;;1599:25:11;;;9441:1:2;;-1:-1:-1;;;;;9415:37:2;;;;;1587:2:11;1572:18;9415:37:2;;;;;;;950:295:3;884:361;;:::o;2034:169:9:-;2108:6;;;-1:-1:-1;;;;;2124:17:9;;;-1:-1:-1;;;;;;2124:17:9;;;;;;;2156:40;;2108:6;;;2124:17;2108:6;;2156:40;;2089:16;;2156:40;2079:124;2034:169;:::o;1799:115:10:-;1104:7;;;;1347:9;1339:38;;;;-1:-1:-1;;;1339:38:10;;10487:2:11;1339:38:10;;;10469:21:11;10526:2;10506:18;;;10499:30;-1:-1:-1;;;10545:18:11;;;10538:46;10601:18;;1339:38:10;10285:340:11;1339:38:10;1858:7:::1;:14:::0;;-1:-1:-1;;1858:14:10::1;1868:4;1858:14;::::0;;1887:20:::1;1894:12;666:10:1::0;;587:96;577:264:4;1104:7:10;;;;778:9:4;770:64;;;;-1:-1:-1;;;770:64:4;;10832:2:11;770:64:4;;;10814:21:11;10871:2;10851:18;;;10844:30;10910:34;10890:18;;;10883:62;-1:-1:-1;;;10961:18:11;;;10954:40;11011:19;;770:64:4;10630:406:11;14:597;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;452:6;449:1;446:13;443:91;;;522:1;517:2;508:6;497:9;493:22;489:31;482:42;443:91;-1:-1:-1;595:2:11;574:15;-1:-1:-1;;570:29:11;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:11:o;824:173::-;892:20;;-1:-1:-1;;;;;941:31:11;;931:42;;921:70;;987:1;984;977:12;921:70;824:173;;;:::o;1002:254::-;1070:6;1078;1131:2;1119:9;1110:7;1106:23;1102:32;1099:52;;;1147:1;1144;1137:12;1099:52;1170:29;1189:9;1170:29;:::i;:::-;1160:39;1246:2;1231:18;;;;1218:32;;-1:-1:-1;;;1002:254:11:o;1635:328::-;1712:6;1720;1728;1781:2;1769:9;1760:7;1756:23;1752:32;1749:52;;;1797:1;1794;1787:12;1749:52;1820:29;1839:9;1820:29;:::i;:::-;1810:39;;1868:38;1902:2;1891:9;1887:18;1868:38;:::i;:::-;1858:48;;1953:2;1942:9;1938:18;1925:32;1915:42;;1635:328;;;;;:::o;2157:180::-;2216:6;2269:2;2257:9;2248:7;2244:23;2240:32;2237:52;;;2285:1;2282;2275:12;2237:52;-1:-1:-1;2308:23:11;;2157:180;-1:-1:-1;2157:180:11:o;2342:186::-;2401:6;2454:2;2442:9;2433:7;2429:23;2425:32;2422:52;;;2470:1;2467;2460:12;2422:52;2493:29;2512:9;2493:29;:::i;:::-;2483:39;2342:186;-1:-1:-1;;;2342:186:11:o;2533:260::-;2601:6;2609;2662:2;2650:9;2641:7;2637:23;2633:32;2630:52;;;2678:1;2675;2668:12;2630:52;2701:29;2720:9;2701:29;:::i;:::-;2691:39;;2749:38;2783:2;2772:9;2768:18;2749:38;:::i;:::-;2739:48;;2533:260;;;;;:::o;2798:380::-;2877:1;2873:12;;;;2920;;;2941:61;;2995:4;2987:6;2983:17;2973:27;;2941:61;3048:2;3040:6;3037:14;3017:18;3014:38;3011:161;;;3094:10;3089:3;3085:20;3082:1;3075:31;3129:4;3126:1;3119:15;3157:4;3154:1;3147:15;3011:161;;2798:380;;;:::o;3592:127::-;3653:10;3648:3;3644:20;3641:1;3634:31;3684:4;3681:1;3674:15;3708:4;3705:1;3698:15;3724:128;3764:3;3795:1;3791:6;3788:1;3785:13;3782:39;;;3801:18;;:::i;:::-;-1:-1:-1;3837:9:11;;3724:128::o;3857:356::-;4059:2;4041:21;;;4078:18;;;4071:30;4137:34;4132:2;4117:18;;4110:62;4204:2;4189:18;;3857:356::o;4218:410::-;4420:2;4402:21;;;4459:2;4439:18;;;4432:30;4498:34;4493:2;4478:18;;4471:62;-1:-1:-1;;;4564:2:11;4549:18;;4542:44;4618:3;4603:19;;4218:410::o;10155:125::-;10195:4;10223:1;10220;10217:8;10214:34;;;10228:18;;:::i;:::-;-1:-1:-1;10265:9:11;;10155:125::o

Swarm Source

ipfs://16df6a487b72e1aed4a8af1010108d29427ff2764bcd60d8f4cc2dafecd19705
Loading