Token Mad Meerkat ETF

Overview CRC20

Price
$1.77 @ 27.830189 CRO (+11.44%)
Fully Diluted Market Cap
Total Supply:
19,366,222.131775 METF

Holders:
4,894 addresses
Balance
0.008452319924335944 METF

Value
$0.01 ( ~0.157232704402516 CRO) [0.0000%]
0x4e463d63cbcbcbffb4d1176236481ca6c0692514
Loading
[ Download CSV Export  ] 
Loading
[ Download CSV Export  ] 
Loading

OVERVIEW

MM Finance is an AMM & DEX on Cronos Chain that offers fee rebates via trade mining with the lowest trading fees on Cronos at 0.17%!


Update? Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume
1
MMFinance (Cronos)
0XB8DF27C687C6AF9AFE845A2AFAD2D01E199F4878-0X97749C9B61F878A880DFE312D2594AE07AED7656$1.77
0.0001035 Btc
$8,179.27
4,526.882 0XB8DF27C687C6AF9AFE845A2AFAD2D01E199F4878
100.0000%

Contract Source Code Verified (Exact Match)

Contract Name:
ETFToken

Compiler Version
v0.7.5+commit.eb77ed08

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-03-15
*/

// File @openzeppelin/contracts/utils/[email protected]



pragma solidity >=0.6.0 <0.8.0;

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

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


// File @openzeppelin/contracts/access/[email protected]



pragma solidity >=0.6.0 <0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), 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 {
        emit OwnershipTransferred(_owner, address(0));
        _owner = 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");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}


// File contracts/library/IBEP20.sol

pragma solidity >=0.4.0;

interface IBEP20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

    /**
     * @dev Returns the bep token owner.
     */
    function getOwner() external view returns (address);

    /**
     * @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 contracts/library/SafeMath.sol

pragma solidity 0.7.5;

library SafeMath {
    uint256 constant WAD = 10 ** 18;
    uint256 constant RAY = 10 ** 27;

    function wad() public pure returns (uint256) {
        return WAD;
    }

    function ray() public pure returns (uint256) {
        return RAY;
    }

    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }

    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a <= b ? a : b;
    }

    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    function sqrt(uint256 a) internal pure returns (uint256 b) {
        if (a > 3) {
            b = a;
            uint256 x = a / 2 + 1;
            while (x < b) {
                b = x;
                x = (a / x + x) / 2;
            }
        } else if (a != 0) {
            b = 1;
        }
    }

    function wmul(uint256 a, uint256 b) internal pure returns (uint256) {
        return mul(a, b) / WAD;
    }

    function wmulRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, b), WAD / 2) / WAD;
    }

    function rmul(uint256 a, uint256 b) internal pure returns (uint256) {
        return mul(a, b) / RAY;
    }

    function rmulRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, b), RAY / 2) / RAY;
    }

    function wdiv(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(mul(a, WAD), b);
    }

    function wdivRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, WAD), b / 2) / b;
    }

    function rdiv(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(mul(a, RAY), b);
    }

    function rdivRound(uint256 a, uint256 b) internal pure returns (uint256) {
        return add(mul(a, RAY), b / 2) / b;
    }

    function wpow(uint256 x, uint256 n) internal pure returns (uint256) {
        uint256 result = WAD;
        while (n > 0) {
            if (n % 2 != 0) {
                result = wmul(result, x);
            }
            x = wmul(x, x);
            n /= 2;
        }
        return result;
    }

    function rpow(uint256 x, uint256 n) internal pure returns (uint256) {
        uint256 result = RAY;
        while (n > 0) {
            if (n % 2 != 0) {
                result = rmul(result, x);
            }
            x = rmul(x, x);
            n /= 2;
        }
        return result;
    }

    function sqrrt(uint256 a) internal pure returns (uint c) {
        if (a > 3) {
            c = a;
            uint b = add( div( a, 2), 1 );
            while (b < c) {
                c = b;
                b = div( add( div( a, b ), b), 2 );
            }
        } else if (a != 0) {
            c = 1;
        }
    }
}


// File contracts/library/Address.sol



pragma solidity 0.7.5;

/**
 * @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) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            codehash := extcodehash(account)
        }
        return (codehash != accountHash && codehash != 0x0);
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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');
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(
        address target,
        bytes memory data,
        uint256 weiValue,
        string memory errorMessage
    ) private returns (bytes memory) {
        require(isContract(target), 'Address: call to non-contract');

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{value: weiValue}(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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


// File contracts/library/SafeBEP20.sol



pragma solidity 0.7.5;



/**
 * @title SafeBEP20
 * @dev Wrappers around BEP20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeBEP20 for IBEP20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeBEP20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(
        IBEP20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IBEP20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IBEP20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IBEP20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            'SafeBEP20: approve from non-zero to non-zero allowance'
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IBEP20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IBEP20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(
            value,
            'SafeBEP20: decreased allowance below zero'
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IBEP20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, 'SafeBEP20: low-level call failed');
        if (returndata.length > 0) {
            // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), 'SafeBEP20: BEP20 operation did not succeed');
        }
    }
}


// File contracts/ETFToken.sol


pragma solidity 0.7.5;



contract BEP20 is Context, IBEP20, Ownable {
    uint256 private constant _preMineSupply = 150000 * 1e18;

    using SafeMath for uint256;
    using Address for address;

    mapping(address => uint256) private _balances;

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

    uint256 private _totalSupply;

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

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

        _mint(msg.sender, _preMineSupply);
    }

    /**
     * @dev Returns the bep token owner.
     */
    function getOwner() external override view returns (address) {
        return owner();
    }

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

    /**
     * @dev Returns the token decimals.
     */
    function decimals() public override view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev Returns the token symbol.
     */
    function symbol() public override view returns (string memory) {
        return _symbol;
    }

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

    function preMineSupply() public pure returns (uint256) {
        return _preMineSupply;
    }

    /**
     * @dev See {BEP20-balanceOf}.
     */
    function balanceOf(address account) public override view returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {BEP20-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 override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

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

    /**
     * @dev See {BEP20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {BEP20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {BEP20};
     *
     * 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 override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(amount, 'BEP20: transfer amount exceeds allowance')
        );
        return true;
    }

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

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {BEP20-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 returns (bool) {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender].sub(subtractedValue, 'BEP20: decreased allowance below zero')
        );
        return true;
    }

    /**
     * @dev Creates `amount` tokens and assigns them to `msg.sender`, increasing
     * the total supply.
     *
     * Requirements
     *
     * - `msg.sender` must be the token owner
     */
    function mint(uint256 amount) public onlyOwner returns (bool) {
        _mint(_msgSender(), amount);
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal {
        require(sender != address(0), 'BEP20: transfer from the zero address');
        require(recipient != address(0), 'BEP20: transfer to the zero address');

        _balances[sender] = _balances[sender].sub(amount, 'BEP20: transfer amount exceeds balance');
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(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
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal returns(bool) {
        require(account != address(0), 'BEP20: mint to the zero address');

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(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 {
        require(account != address(0), 'BEP20: burn from the zero address');

        _balances[account] = _balances[account].sub(amount, 'BEP20: burn amount exceeds balance');
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner`s tokens.
     *
     * This is 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 {
        require(owner != address(0), 'BEP20: approve from the zero address');
        require(spender != address(0), 'BEP20: approve to the zero address');

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

    /**
     * @dev Destroys `amount` tokens from `account`.`amount` is then deducted
     * from the caller's allowance.
     *
     * See {_burn} and {_approve}.
     */
    function _burnFrom(address account, uint256 amount) internal {
        _burn(account, amount);
        _approve(
            account,
            _msgSender(),
            _allowances[account][_msgSender()].sub(amount, 'BEP20: burn amount exceeds allowance')
        );
    }
}

library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, 'EnumerableSet: index out of bounds');
        return set._values[index];
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(value)));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint256(_at(set._inner, index)));
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}
// Meerkat token with Governance.
contract ETFToken is BEP20('Mad Meerkat ETF', 'METF') {
    using EnumerableSet for EnumerableSet.AddressSet;
    EnumerableSet.AddressSet private _minters;

    /// @notice Creates `_amount` token to `_to`.
    function mint(address _to, uint256 _amount) public onlyMinter returns(bool) {
        _mint(_to, _amount);
        return true;
    }

    function safe32(uint n, string memory errorMessage) internal pure returns (uint32) {
        require(n < 2**32, errorMessage);
        return uint32(n);
    }

    function getChainId() internal pure returns (uint) {
        uint256 chainId;
        assembly { chainId := chainid() }
        return chainId;
    }

    function addMinter(address _addMinter) public onlyOwner returns (bool) {
        require(_addMinter != address(0), "MMF: _addMinter is the zero address");
        return EnumerableSet.add(_minters, _addMinter);
    }

    function delMinter(address _delMinter) public onlyOwner returns (bool) {
        require(_delMinter != address(0), "MMF: _delMinter is the zero address");
        return EnumerableSet.remove(_minters, _delMinter);
    }

    function getMinterLength() public view returns (uint256) {
        return EnumerableSet.length(_minters);
    }

    function isMinter(address account) public view returns (bool) {
        return EnumerableSet.contains(_minters, account);
    }

    function getMinter(uint256 _index) public view onlyOwner returns (address){
        require(_index <= getMinterLength() - 1, "MMF: index out of bounds");
        return EnumerableSet.at(_minters, _index);
    }

    // modifier for mint function
    modifier onlyMinter() {
        require(isMinter(msg.sender), "caller is not the minter");
        _;
    }
}

Contract Security Audit

Contract ABI

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"_addMinter","type":"address"}],"name":"addMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_delMinter","type":"address"}],"name":"delMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_index","type":"uint256"}],"name":"getMinter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getMinterLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isMinter","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","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":"preMineSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

38144:1775:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39292:113;;;:::i;:::-;;;;;;;;;;;;;;;;22830:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24420:161;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;24420:161:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;23414:95;;;:::i;23306:100::-;;;:::i;39062:222::-;;;;;;;;;;;;;;;;-1:-1:-1;39062:222:0;-1:-1:-1;;;;;39062:222:0;;:::i;25052:397::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;25052:397:0;;;;;;;;;;;;;;;;;:::i;22989:92::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;25857:210;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;25857:210:0;;;;;;;;:::i;38361:136::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;38361:136:0;;;;;;;;:::i;39550:213::-;;;;;;;;;;;;;;;;-1:-1:-1;39550:213:0;;:::i;:::-;;;;-1:-1:-1;;;;;39550:213:0;;;;;;;;;;;;;;23571:119;;;;;;;;;;;;;;;;-1:-1:-1;23571:119:0;-1:-1:-1;;;;;23571:119:0;;:::i;2766:148::-;;;:::i;:::-;;22673:94;;;:::i;2115:87::-;;;:::i;23146:96::-;;;:::i;38835:219::-;;;;;;;;;;;;;;;;-1:-1:-1;38835:219:0;-1:-1:-1;;;;;38835:219:0;;:::i;27098:130::-;;;;;;;;;;;;;;;;-1:-1:-1;27098:130:0;;:::i;26569:311::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;26569:311:0;;;;;;;;:::i;23902:167::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;23902:167:0;;;;;;;;:::i;39413:129::-;;;;;;;;;;;;;;;;-1:-1:-1;39413:129:0;-1:-1:-1;;;;;39413:129:0;;:::i;24131:143::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;24131:143:0;;;;;;;;;;:::i;3069:244::-;;;;;;;;;;;;;;;;-1:-1:-1;3069:244:0;-1:-1:-1;;;;;3069:244:0;;:::i;39292:113::-;39340:7;39367:30;39388:8;39367:20;:30::i;:::-;39360:37;;39292:113;:::o;22830:92::-;22909:5;22902:12;;;;;;;;-1:-1:-1;;22902:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22876:13;;22902:12;;22909:5;;22902:12;;22909:5;22902:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22830:92;:::o;24420:161::-;24495:4;24512:39;24521:12;:10;:12::i;:::-;24535:7;24544:6;24512:8;:39::i;:::-;-1:-1:-1;24569:4:0;24420:161;;;;;:::o;23414:95::-;21746:13;23414:95;:::o;23306:100::-;23386:12;;23306:100;:::o;39062:222::-;39127:4;2346:12;:10;:12::i;:::-;-1:-1:-1;;;;;2335:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2335:23:0;;2327:68;;;;;-1:-1:-1;;;2327:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2327:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;39152:24:0;::::1;39144:72;;;;-1:-1:-1::0;;;39144:72:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39234:42;39255:8;39265:10;39234:20;:42::i;25052:397::-:0;25184:4;25201:36;25211:6;25219:9;25230:6;25201:9;:36::i;:::-;25248:171;25271:6;25292:12;:10;:12::i;:::-;25319:89;25357:6;25319:89;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;25319:19:0;;;;;;:11;:19;;;;;;25339:12;:10;:12::i;:::-;-1:-1:-1;;;;;25319:33:0;;;;;;;;;;;;-1:-1:-1;25319:33:0;;;:89;:37;:89::i;:::-;25248:8;:171::i;:::-;-1:-1:-1;25437:4:0;25052:397;;;;;:::o;22989:92::-;23064:9;;;;22989:92;:::o;25857:210::-;25937:4;25954:83;25963:12;:10;:12::i;:::-;25977:7;25986:50;26025:10;25986:11;:25;25998:12;:10;:12::i;:::-;-1:-1:-1;;;;;25986:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;25986:25:0;;;:34;;;;;;;;;;;:38;:50::i;38361:136::-;38431:4;39847:20;39856:10;39847:8;:20::i;:::-;39839:57;;;;;-1:-1:-1;;;39839:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;38448:19:::1;38454:3;38459:7;38448:5;:19::i;39550:213::-:0;39616:7;2346:12;:10;:12::i;:::-;-1:-1:-1;;;;;2335:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2335:23:0;;2327:68;;;;;-1:-1:-1;;;2327:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2327:68:0;;;;;;;;;;;;;;;39673:1:::1;39653:17;:15;:17::i;:::-;:21;39643:6;:31;;39635:68;;;::::0;;-1:-1:-1;;;39635:68:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;::::1;::::0;;;;;;;;;;;;;::::1;;39721:34;39738:8;39748:6;39721:16;:34::i;23571:119::-:0;-1:-1:-1;;;;;23664:18:0;23637:7;23664:18;;;:9;:18;;;;;;;23571:119::o;2766:148::-;2346:12;:10;:12::i;:::-;-1:-1:-1;;;;;2335:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2335:23:0;;2327:68;;;;;-1:-1:-1;;;2327:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2327:68:0;;;;;;;;;;;;;;;2873:1:::1;2857:6:::0;;2836:40:::1;::::0;-1:-1:-1;;;;;2857:6:0;;::::1;::::0;2836:40:::1;::::0;2873:1;;2836:40:::1;2904:1;2887:19:::0;;-1:-1:-1;;;;;;2887:19:0::1;::::0;;2766:148::o;22673:94::-;22725:7;22752;2115:87;2161:7;2188:6;-1:-1:-1;;;;;2188:6:0;2115:87;:::o;23146:96::-;23227:7;23220:14;;;;;;;;-1:-1:-1;;23220:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23194:13;;23220:14;;23227:7;;23220:14;;23227:7;23220:14;;;;;;;;;;;;;;;;;;;;;;;;38835:219;38900:4;2346:12;:10;:12::i;:::-;-1:-1:-1;;;;;2335:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2335:23:0;;2327:68;;;;;-1:-1:-1;;;2327:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2327:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;38925:24:0;::::1;38917:72;;;;-1:-1:-1::0;;;38917:72:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39007:39;39025:8;39035:10;39007:17;:39::i;27098:130::-:0;27154:4;2346:12;:10;:12::i;:::-;-1:-1:-1;;;;;2335:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2335:23:0;;2327:68;;;;;-1:-1:-1;;;2327:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2327:68:0;;;;;;;;;;;;;;;27171:27:::1;27177:12;:10;:12::i;:::-;27191:6;27171:5;:27::i;26569:311::-:0;26654:4;26671:179;26694:12;:10;:12::i;:::-;26721:7;26743:96;26782:15;26743:96;;;;;;;;;;;;;;;;;:11;:25;26755:12;:10;:12::i;:::-;-1:-1:-1;;;;;26743:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;26743:25:0;;;:34;;;;;;;;;;;:96;:38;:96::i;23902:167::-;23980:4;23997:42;24007:12;:10;:12::i;:::-;24021:9;24032:6;23997:9;:42::i;39413:129::-;39469:4;39493:41;39516:8;39526:7;39493:22;:41::i;24131:143::-;-1:-1:-1;;;;;24239:18:0;;;24212:7;24239:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;24131:143::o;3069:244::-;2346:12;:10;:12::i;:::-;-1:-1:-1;;;;;2335:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;2335:23:0;;2327:68;;;;;-1:-1:-1;;;2327:68:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2327:68:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;3158:22:0;::::1;3150:73;;;;-1:-1:-1::0;;;3150:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3260:6;::::0;;3239:38:::1;::::0;-1:-1:-1;;;;;3239:38:0;;::::1;::::0;3260:6;::::1;::::0;3239:38:::1;::::0;::::1;3288:6;:17:::0;;-1:-1:-1;;;;;;3288:17:0::1;-1:-1:-1::0;;;;;3288:17:0;;;::::1;::::0;;;::::1;::::0;;3069:244::o;6875:181::-;6933:7;6965:5;;;6989:6;;;;6981:46;;;;;-1:-1:-1;;;6981:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7047:1;6875:181;-1:-1:-1;;;6875:181:0:o;35869:117::-;35932:7;35959:19;35967:3;35959:7;:19::i;642:106::-;730:10;642:106;:::o;29946:372::-;-1:-1:-1;;;;;30074:19:0;;30066:68;;;;-1:-1:-1;;;30066:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;30153:21:0;;30145:68;;;;-1:-1:-1;;;30145:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;30226:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;30278:32;;;;;;;;;;;;;;;;;29946:372;;;:::o;35390:149::-;35463:4;35487:44;35495:3;-1:-1:-1;;;;;35515:14:0;;35487:7;:44::i;27718:505::-;-1:-1:-1;;;;;27850:20:0;;27842:70;;;;-1:-1:-1;;;27842:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;27931:23:0;;27923:71;;;;-1:-1:-1;;;27923:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28027;28049:6;28027:71;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;28027:17:0;;;;;;:9;:17;;;;;;;:71;:21;:71::i;:::-;-1:-1:-1;;;;;28007:17:0;;;;;;;:9;:17;;;;;;:91;;;;28132:20;;;;;;;:32;;28157:6;28132:24;:32::i;:::-;-1:-1:-1;;;;;28109:20:0;;;;;;;:9;:20;;;;;;;;;:55;;;;28180:35;;;;;;;28109:20;;28180:35;;;;;;;;;;;;;27718:505;;;:::o;7208:192::-;7294:7;7330:12;7322:6;;;;7314:29;;;;-1:-1:-1;;;7314:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;7366:5:0;;;7208:192::o;28504:322::-;28569:4;-1:-1:-1;;;;;28594:21:0;;28586:65;;;;;-1:-1:-1;;;28586:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;28679:12;;:24;;28696:6;28679:16;:24::i;:::-;28664:12;:39;-1:-1:-1;;;;;28735:18:0;;;;;;:9;:18;;;;;;:30;;28758:6;28735:22;:30::i;:::-;-1:-1:-1;;;;;28714:18:0;;;;;;:9;:18;;;;;;;;:51;;;;28781:37;;;;;;;28714:18;;;;28781:37;;;;;;;;;;28504:322;;;;:::o;36340:149::-;36414:7;36457:22;36461:3;36473:5;36457:3;:22::i;35071:143::-;35141:4;35165:41;35170:3;-1:-1:-1;;;;;35190:14:0;;35165:4;:41::i;35625:158::-;35705:4;35729:46;35739:3;-1:-1:-1;;;;;35759:14:0;;35729:9;:46::i;34150:109::-;34233:18;;34150:109::o;32292:1557::-;32358:4;32497:19;;;:12;;;:19;;;;;;32533:15;;32529:1313;;32981:18;;-1:-1:-1;;32932:14:0;;;;32981:22;;;;32908:21;;32981:3;;:22;;33268;;;;;;;;;;;;;;33248:42;;33414:9;33385:3;:11;;33397:13;33385:26;;;;;;;;;;;;;;;;;;;:38;;;;33491:23;;;33533:1;33491:12;;;:23;;;;;;33517:17;;;33491:43;;33643:17;;33491:3;;33643:17;;;;;;;;;;;;;;;;;;;;;;33738:3;:12;;:19;33751:5;33738:19;;;;;;;;;;;33731:26;;;33781:4;33774:11;;;;;;;;32529:1313;33825:5;33818:12;;;;;34613:204;34708:18;;34680:7;;34708:26;-1:-1:-1;34700:73:0;;;;-1:-1:-1;;;34700:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34791:3;:11;;34803:5;34791:18;;;;;;;;;;;;;;;;34784:25;;34613:204;;;;:::o;31702:414::-;31765:4;31787:21;31797:3;31802:5;31787:9;:21::i;:::-;31782:327;;-1:-1:-1;31825:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;32008:18;;31986:19;;;:12;;;:19;;;;;;:40;;;;32041:11;;31782:327;-1:-1:-1;32092:5:0;32085:12;;33935:129;34008:4;34032:19;;;:12;;;;;:19;;;;;;:24;;;33935:129::o

Swarm Source

ipfs://704581c67d823c4b41aff70d9e134c2d0460106e39b505fac7eb762b875c73d6
Loading