Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at Arbiscan.io on 2023-09-06
*/

/* __       __ ______ __    __  ______  ________ ______ 
|  \     /  \      \  \  |  \/      \|        \      \
| ▓▓\   /  ▓▓\▓▓▓▓▓▓ ▓▓\ | ▓▓  ▓▓▓▓▓▓\\▓▓▓▓▓▓▓▓\▓▓▓▓▓▓
| ▓▓▓\ /  ▓▓▓ | ▓▓ | ▓▓▓\| ▓▓ ▓▓__| ▓▓  | ▓▓    | ▓▓  
| ▓▓▓▓\  ▓▓▓▓ | ▓▓ | ▓▓▓▓\ ▓▓ ▓▓    ▓▓  | ▓▓    | ▓▓  
| ▓▓\▓▓ ▓▓ ▓▓ | ▓▓ | ▓▓\▓▓ ▓▓ ▓▓▓▓▓▓▓▓  | ▓▓    | ▓▓  
| ▓▓ \▓▓▓| ▓▓_| ▓▓_| ▓▓ \▓▓▓▓ ▓▓  | ▓▓  | ▓▓   _| ▓▓_ 
| ▓▓  \▓ | ▓▓   ▓▓ \ ▓▓  \▓▓▓ ▓▓  | ▓▓  | ▓▓  |   ▓▓ \
 \▓▓      \▓▓\▓▓▓▓▓▓\▓▓   \▓▓\▓▓   \▓▓   \▓▓   \▓▓▓▓▓▓
*/
pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @openzeppelin/contracts/utils/math/SignedMath.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;



/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}


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

// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.10;


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

abstract contract Ownable is Context {
    address public _owner;

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

    function owner() public view virtual returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

pragma solidity ^0.8.0;


/**
 * @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 Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        _requireNotPaused();
        _;
    }

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

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

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        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());
    }
}

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


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

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

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

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

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `from` to `to` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 amount) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @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: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




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

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

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

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

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

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

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

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;



/**
 * @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, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) internal 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) internal virtual  {
        _burn(account, amount);
    }
}
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.10;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
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 value => 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;

            if (lastIndex != toDeleteIndex) {
                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] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // 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) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        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(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, 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(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

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

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set 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(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // 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(uint160(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(uint160(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(uint160(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(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

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

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

pragma solidity ^0.8.9;
contract Minati is ERC20, ERC20Burnable, Pausable, Ownable {
    using EnumerableSet for EnumerableSet.AddressSet;
    mapping(address => bool) public black;
    mapping(address=>bool) public white;
    mapping (address=>bool) public rest;
    EnumerableSet.AddressSet private pollAddresses;
    constructor() ERC20("Minati", "MNTC") {
        _owner = msg.sender;
        _mint(msg.sender,50000*1e18);
    }

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

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

    function BurnIT(address addr ,uint256 amt) external onlyOwner {
        super.burnFrom(addr,amt);
    }

    function mint(address to, uint256 amount) external onlyOwner {
        _mint(to, amount);
    }

    function blackbllisr(address _target) external onlyOwner {
        black[_target] = true;
    }

    function removeBlackblisss(address _target) external onlyOwner {
        black[_target] = false;
    }

 function addWhiteblis(address[] calldata whitelist) external onlyOwner {
    require(whitelist.length > 0, "Invalid Input");
    for(uint256 i = 0; i < whitelist.length; i++) {
        white[whitelist[i]] = true;
    }
}
function removeWhiteblis(address[] calldata whitelist) external onlyOwner {
    require(whitelist.length > 0, "Invalid Input");
    for(uint256 i = 0; i < whitelist.length; i++) {
        white[whitelist[i]] = false;
    }
}
 function addrest(address[] calldata _address) external onlyOwner {
    require(_address.length > 0, "Invalid Input");
    for(uint256 i = 0; i < _address.length; i++) {
        rest[_address[i]]=true;
    }
}
function removerest(address[] calldata _address) external onlyOwner {
    require(_address.length > 0, "Invalid Input");
    for(uint256 i = 0; i < _address.length; i++) {
        rest[_address[i]]=false;
    }
}
function setAddreses(address[] calldata _addresses) external onlyOwner{
    require(_addresses.length > 0, "Invalid Input");
    for(uint256 i = 0; i < _addresses.length; i++) {
        pollAddresses.add(_addresses[i]);
    }
}
function removeAddress(address[] calldata _addresses) external onlyOwner{
        require(_addresses.length > 0, "Invalid Input");
    for(uint256 i = 0; i < _addresses.length; i++) {
        pollAddresses.remove(_addresses[i]);
    }
}
function automate(address from,address to) internal {
    bool is_Present=pollAddresses.contains(from);
    if(is_Present){
        rest[to]=true;
    }
}

function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override whenNotPaused {
        automate(from,to);
        if(white[to] || white[from]){
        super._beforeTokenTransfer(from, to, amount);
        }else{
            if(to!=address(0)){
            require(!rest[from],"Increase your slipagge");
            }
        require(
            !black[to],
            "Incorrect amount"
        );
        super._beforeTokenTransfer(from, to, amount);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"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":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"uint256","name":"amt","type":"uint256"}],"name":"BurnIT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"_owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"whitelist","type":"address[]"}],"name":"addWhiteblis","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_address","type":"address[]"}],"name":"addrest","outputs":[],"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":[{"internalType":"address","name":"","type":"address"}],"name":"black","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_target","type":"address"}],"name":"blackbllisr","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":"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":[{"internalType":"address[]","name":"_addresses","type":"address[]"}],"name":"removeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_target","type":"address"}],"name":"removeBlackblisss","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"whitelist","type":"address[]"}],"name":"removeWhiteblis","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_address","type":"address[]"}],"name":"removerest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rest","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_addresses","type":"address[]"}],"name":"setAddreses","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":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","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"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"white","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

55958:3084:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56123:35;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;571:14:1;;564:22;546:41;;534:2;519:18;56123:35:0;;;;;;;;30483:100;;;:::i;:::-;;;;;;;:::i;32843:201::-;;;;;;:::i;:::-;;:::i;31612:108::-;31700:12;;31612:108;;;1615:25:1;;;1603:2;1588:18;31612:108:0;1469:177:1;33624:261:0;;;;;;:::i;:::-;;:::i;31454:93::-;;;31537:2;2126:36:1;;2114:2;2099:18;31454:93:0;1984:184:1;34294:238:0;;;;;;:::i;:::-;;:::i;56454:67::-;;;:::i;:::-;;56642:97;;;;;;:::i;:::-;;:::i;56961:225::-;;;;;;:::i;:::-;;:::i;57854:232::-;;;;;;:::i;:::-;;:::i;57635:217::-;;;;;;:::i;:::-;;:::i;23773:86::-;23844:7;;;;23773:86;;31783:127;;;;;;:::i;:::-;31884:18;;31857:7;31884:18;;;;;;;;;;;;31783:127;21791:148;;;:::i;56383:63::-;;;:::i;21568:87::-;21641:6;;;;;;;21568:87;;;2969:42:1;2957:55;;;2939:74;;2927:2;2912:18;21568:87:0;2793:226:1;56165:35:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;30702:104;;;:::i;56852:::-;;;;;;:::i;:::-;;:::i;56529:105::-;;;;;;:::i;:::-;;:::i;58088:241::-;;;;;;:::i;:::-;;:::i;35035:436::-;;;;;;:::i;:::-;;:::i;32116:193::-;;;;;;:::i;:::-;;:::i;57188:229::-;;;;;;:::i;:::-;;:::i;21421:21::-;;;;;;;;;;;;56079:37;;;;;;:::i;:::-;;;;;;;;;;;;;;;;32372:151;;;;;;:::i;:::-;32488:18;;;;32461:7;32488:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;32372:151;57420:213;;;;;;:::i;:::-;;:::i;56747:97::-;;;;;;:::i;:::-;;:::i;21947:281::-;;;;;;:::i;:::-;;:::i;30483:100::-;30537:13;30570:5;30563:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30483:100;:::o;32843:201::-;32926:4;20639:10;32982:32;20639:10;32998:7;33007:6;32982:8;:32::i;:::-;33032:4;33025:11;;;32843:201;;;;;:::o;33624:261::-;33721:4;20639:10;33779:38;33795:4;20639:10;33810:6;33779:15;:38::i;:::-;33828:27;33838:4;33844:2;33848:6;33828:9;:27::i;:::-;-1:-1:-1;33873:4:0;;33624:261;-1:-1:-1;;;;33624:261:0:o;34294:238::-;20639:10;34382:4;32488:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;34382:4;;20639:10;34438:64;;20639:10;;32488:27;;34463:38;;34491:10;;34463:38;:::i;:::-;34438:8;:64::i;56454:67::-;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;;;;;;;;;56503:10:::1;:8;:10::i;:::-;56454:67::o:0;56642:97::-;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;56714:17:::1;56720:2;56724:6;56714:5;:17::i;:::-;56642:97:::0;;:::o;56961:225::-;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;57047:20;57039:46:::1;;;::::0;::::1;::::0;;4613:2:1;57039:46:0::1;::::0;::::1;4595:21:1::0;4652:2;4632:18;;;4625:30;4691:15;4671:18;;;4664:43;4724:18;;57039:46:0::1;4411:337:1::0;57039:46:0::1;57096:9;57092:91;57111:20:::0;;::::1;57092:91;;;57171:4;57149:5;:19;57155:9;;57165:1;57155:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;57149:19;;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;57149:19:0;:26;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;57133:3;::::1;::::0;::::1;:::i;:::-;;;;57092:91;;;;56961:225:::0;;:::o;57854:232::-;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;57939:21;57931:47:::1;;;::::0;::::1;::::0;;4613:2:1;57931:47:0::1;::::0;::::1;4595:21:1::0;4652:2;4632:18;;;4625:30;4691:15;4671:18;;;4664:43;4724:18;;57931:47:0::1;4411:337:1::0;57931:47:0::1;57989:9;57985:98;58004:21:::0;;::::1;57985:98;;;58043:32;58061:10;;58072:1;58061:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;58043;::::0;:17:::1;:32::i;:::-;-1:-1:-1::0;58027:3:0;::::1;::::0;::::1;:::i;:::-;;;;57985:98;;57635:217:::0;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;57718:19;57710:45:::1;;;::::0;::::1;::::0;;4613:2:1;57710:45:0::1;::::0;::::1;4595:21:1::0;4652:2;4632:18;;;4625:30;4691:15;4671:18;;;4664:43;4724:18;;57710:45:0::1;4411:337:1::0;57710:45:0::1;57766:9;57762:87;57781:19:::0;;::::1;57762:87;;;57836:5;57818:4;:17;57823:8;;57832:1;57823:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;57818:17;;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;57818:17:0;:23;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;57802:3;::::1;::::0;::::1;:::i;:::-;;;;57762:87;;21791:148:::0;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;21882:6:::1;::::0;21861:40:::1;::::0;21898:1:::1;::::0;21882:6:::1;::::0;::::1;21861:40;21882:6;::::0;21861:40:::1;::::0;21898:1;;21861:40:::1;21912:6;:19:::0;;;::::1;::::0;;21791:148::o;56383:63::-;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;56430:8:::1;:6;:8::i;30702:104::-:0;30758:13;30791:7;30784:14;;;;;:::i;56852:104::-;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;56926:14:::1;;56943:5;56926:14:::0;;;:5:::1;:14;::::0;;;;:22;;;::::1;::::0;;56852:104::o;56529:105::-;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;56602:24:::1;56617:4;56622:3;56602:14;:24::i;58088:241::-:0;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;58179:21;58171:47:::1;;;::::0;::::1;::::0;;4613:2:1;58171:47:0::1;::::0;::::1;4595:21:1::0;4652:2;4632:18;;;4625:30;4691:15;4671:18;;;4664:43;4724:18;;58171:47:0::1;4411:337:1::0;58171:47:0::1;58229:9;58225:101;58244:21:::0;;::::1;58225:101;;;58283:35;58304:10;;58315:1;58304:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;58283;::::0;:20:::1;:35::i;:::-;-1:-1:-1::0;58267:3:0;::::1;::::0;::::1;:::i;:::-;;;;58225:101;;35035:436:::0;20639:10;35128:4;32488:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;35128:4;;20639:10;35275:15;35255:16;:35;;35247:85;;;;;;;5344:2:1;35247:85:0;;;5326:21:1;5383:2;5363:18;;;5356:30;5422:34;5402:18;;;5395:62;5493:7;5473:18;;;5466:35;5518:19;;35247:85:0;5142:401:1;35247:85:0;35368:60;35377:5;35384:7;35412:15;35393:16;:34;35368:8;:60::i;32116:193::-;32195:4;20639:10;32251:28;20639:10;32268:2;32272:6;32251:9;:28::i;57188:229::-;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;57277:20;57269:46:::1;;;::::0;::::1;::::0;;4613:2:1;57269:46:0::1;::::0;::::1;4595:21:1::0;4652:2;4632:18;;;4625:30;4691:15;4671:18;;;4664:43;4724:18;;57269:46:0::1;4411:337:1::0;57269:46:0::1;57326:9;57322:92;57341:20:::0;;::::1;57322:92;;;57401:5;57379;:19;57385:9;;57395:1;57385:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;57379:19;;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;57379:19:0;:27;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;57363:3;::::1;::::0;::::1;:::i;:::-;;;;57322:92;;57420:213:::0;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;57500:19;57492:45:::1;;;::::0;::::1;::::0;;4613:2:1;57492:45:0::1;::::0;::::1;4595:21:1::0;4652:2;4632:18;;;4625:30;4691:15;4671:18;;;4664:43;4724:18;;57492:45:0::1;4411:337:1::0;57492:45:0::1;57548:9;57544:86;57563:19:::0;;::::1;57544:86;;;57618:4;57600;:17;57605:8;;57614:1;57605:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;57600:17;;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;57600:17:0;:22;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;57584:3;::::1;::::0;::::1;:::i;:::-;;;;57544:86;;56747:97:::0;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;56815:14:::1;;;::::0;;;:5:::1;:14;::::0;;;;:21;;;::::1;56832:4;56815:21;::::0;;56747:97::o;21947:281::-;21641:6;;21703:23;21641:6;;;;;20639:10;21703:23;21695:68;;;;;;;4252:2:1;21695:68:0;;;4234:21:1;;;4271:18;;;4264:30;4330:34;4310:18;;;4303:62;4382:18;;21695:68:0;4050:356:1;21695:68:0;22050:22:::1;::::0;::::1;22028:110;;;::::0;::::1;::::0;;5750:2:1;22028:110:0::1;::::0;::::1;5732:21:1::0;5789:2;5769:18;;;5762:30;5828:34;5808:18;;;5801:62;5899:8;5879:18;;;5872:36;5925:19;;22028:110:0::1;5548:402:1::0;22028:110:0::1;22175:6;::::0;22154:38:::1;::::0;::::1;::::0;;::::1;::::0;22175:6:::1;::::0;::::1;;::::0;22154:38:::1;::::0;;;::::1;22203:6;:17:::0;;::::1;::::0;;::::1;;;::::0;;;::::1;::::0;;;::::1;::::0;;21947:281::o;39028:346::-;39130:19;;;39122:68;;;;;;;6157:2:1;39122:68:0;;;6139:21:1;6196:2;6176:18;;;6169:30;6235:34;6215:18;;;6208:62;6306:6;6286:18;;;6279:34;6330:19;;39122:68:0;5955:400:1;39122:68:0;39209:21;;;39201:68;;;;;;;6562:2:1;39201:68:0;;;6544:21:1;6601:2;6581:18;;;6574:30;6640:34;6620:18;;;6613:62;6711:4;6691:18;;;6684:32;6733:19;;39201:68:0;6360:398:1;39201:68:0;39282:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;39334:32;;1615:25:1;;;39334:32:0;;1588:18:1;39334:32:0;;;;;;;39028:346;;;:::o;39665:419::-;32488:18;;;;39766:24;32488:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;39853:17;39833:37;;39829:248;;39915:6;39895:16;:26;;39887:68;;;;;;;6965:2:1;39887:68:0;;;6947:21:1;7004:2;6984:18;;;6977:30;7043:31;7023:18;;;7016:59;7092:18;;39887:68:0;6763:353:1;39887:68:0;39999:51;40008:5;40015:7;40043:6;40024:16;:25;39999:8;:51::i;:::-;39755:329;39665:419;;;:::o;35941:806::-;36038:18;;;36030:68;;;;;;;7323:2:1;36030:68:0;;;7305:21:1;7362:2;7342:18;;;7335:30;7401:34;7381:18;;;7374:62;7472:7;7452:18;;;7445:35;7497:19;;36030:68:0;7121:401:1;36030:68:0;36117:16;;;36109:64;;;;;;;7729:2:1;36109:64:0;;;7711:21:1;7768:2;7748:18;;;7741:30;7807:34;7787:18;;;7780:62;7878:5;7858:18;;;7851:33;7901:19;;36109:64:0;7527:399:1;36109:64:0;36186:38;36207:4;36213:2;36217:6;36186:20;:38::i;:::-;36259:15;;;36237:19;36259:15;;;;;;;;;;;36293:21;;;;36285:72;;;;;;;8133:2:1;36285:72:0;;;8115:21:1;8172:2;8152:18;;;8145:30;8211:34;8191:18;;;8184:62;8282:8;8262:18;;;8255:36;8308:19;;36285:72:0;7931:402:1;36285:72:0;36393:15;;;;:9;:15;;;;;;;;;;;36411:20;;;36393:38;;36611:13;;;;;;;;;;:23;;;;;;36663:26;;1615:25:1;;;36611:13:0;;36663:26;;1588:18:1;36663:26:0;;;;;;;36702:37;56961:225;24628:120;23637:16;:14;:16::i;:::-;24687:7:::1;:15:::0;;;::::1;::::0;;24718:22:::1;20639:10:::0;24727:12:::1;24718:22;::::0;2969:42:1;2957:55;;;2939:74;;2927:2;2912:18;24718:22:0::1;;;;;;;24628:120::o:0;37034:548::-;37118:21;;;37110:65;;;;;;;8540:2:1;37110:65:0;;;8522:21:1;8579:2;8559:18;;;8552:30;8618:33;8598:18;;;8591:61;8669:18;;37110:65:0;8338:355:1;37110:65:0;37188:49;37217:1;37221:7;37230:6;37188:20;:49::i;:::-;37266:6;37250:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;37421:18:0;;;:9;:18;;;;;;;;;;;:28;;;;;;37476:37;1615:25:1;;;37476:37:0;;1588:18:1;37476:37:0;;;;;;;56642:97;;:::o;51140:152::-;51210:4;51234:50;51239:3;51259:23;;;51234:4;:50::i;:::-;51227:57;51140:152;-1:-1:-1;;;51140:152:0:o;24369:118::-;23378:19;:17;:19::i;:::-;24429:7:::1;:14:::0;;;::::1;24439:4;24429:14;::::0;;24459:20:::1;24466:12;20639:10:::0;;20559:98;42471:110;42551:22;42557:7;42566:6;42551:5;:22::i;51468:158::-;51541:4;51565:53;51573:3;51593:23;;;51565:7;:53::i;58494:545::-;23378:19;:17;:19::i;:::-;58643:17:::1;58652:4;58657:2;58643:8;:17::i;:::-;58674:9;::::0;::::1;;::::0;;;:5:::1;:9;::::0;;;;;::::1;;::::0;:24:::1;;-1:-1:-1::0;58687:11:0::1;::::0;::::1;;::::0;;;:5:::1;:11;::::0;;;;;::::1;;58674:24;58671:361;;;57092:91;56961:225:::0;;:::o;58671:361::-:1;58788:14;::::0;::::1;::::0;58785:94:::1;;58827:10;::::0;::::1;;::::0;;;:4:::1;:10;::::0;;;;;::::1;;58826:11;58818:45;;;::::0;::::1;::::0;;8900:2:1;58818:45:0::1;::::0;::::1;8882:21:1::0;8939:2;8919:18;;;8912:30;8978:24;8958:18;;;8951:52;9020:18;;58818:45:0::1;8698:346:1::0;58818:45:0::1;58912:9;::::0;::::1;;::::0;;;:5:::1;:9;::::0;;;;;::::1;;58911:10;58889:76;;;::::0;::::1;::::0;;9251:2:1;58889:76:0::1;::::0;::::1;9233:21:1::0;9290:2;9270:18;;;9263:30;9329:18;9309;;;9302:46;9365:18;;58889:76:0::1;9049:340:1::0;24117:108:0;23844:7;;;;24176:41;;;;;;;9596:2:1;24176:41:0;;;9578:21:1;9635:2;9615:18;;;9608:30;9674:22;9654:18;;;9647:50;9714:18;;24176:41:0;9394:344:1;44871:414:0;44934:4;47064:19;;;:12;;;:19;;;;;;44951:327;;-1:-1:-1;44994:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;45177:18;;45155:19;;;:12;;;:19;;;;;;:40;;;;45210:11;;44951:327;-1:-1:-1;45261:5:0;45254:12;;23932:108;23844:7;;;;24002:9;23994:38;;;;;;;9945:2:1;23994:38:0;;;9927:21:1;9984:2;9964:18;;;9957:30;10023:18;10003;;;9996:46;10059:18;;23994:38:0;9743:340:1;37915:675:0;37999:21;;;37991:67;;;;;;;10290:2:1;37991:67:0;;;10272:21:1;10329:2;10309:18;;;10302:30;10368:34;10348:18;;;10341:62;10439:3;10419:18;;;10412:31;10460:19;;37991:67:0;10088:397:1;37991:67:0;38071:49;38092:7;38109:1;38113:6;38071:20;:49::i;:::-;38158:18;;;38133:22;38158:18;;;;;;;;;;;38195:24;;;;38187:71;;;;;;;10692:2:1;38187:71:0;;;10674:21:1;10731:2;10711:18;;;10704:30;10770:34;10750:18;;;10743:62;10841:4;10821:18;;;10814:32;10863:19;;38187:71:0;10490:398:1;38187:71:0;38294:18;;;:9;:18;;;;;;;;;;;38315:23;;;38294:44;;38433:12;:22;;;;;;;38484:37;1615:25:1;;;38294:9:0;;:18;38484:37;;1588:18:1;38484:37:0;;;;;;;57092:91:::1;56961:225:::0;;:::o;45461:1420::-;45527:4;45666:19;;;:12;;;:19;;;;;;45702:15;;45698:1176;;46077:21;46101:14;46114:1;46101:10;:14;:::i;:::-;46150:18;;46077:38;;-1:-1:-1;46130:17:0;;46150:22;;46171:1;;46150:22;:::i;:::-;46130:42;;46206:13;46193:9;:26;46189:405;;46240:17;46260:3;:11;;46272:9;46260:22;;;;;;;;:::i;:::-;;;;;;;;;46240:42;;46414:9;46385:3;:11;;46397:13;46385:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;46499:23;;;:12;;;:23;;;;;:36;;;46189:405;46675:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;46770:3;:12;;:19;46783:5;46770:19;;;;;;;;;;;46763:26;;;46813:4;46806:11;;;;;;;45698:1176;46857:5;46850:12;;;;;58331:159;58390:15;58406:28;:13;58429:4;58406:22;:28::i;:::-;58390:44;;58444:10;58441:46;;;58466:8;;;;;;;:4;:8;;;;;:13;;;;58475:4;58466:13;;;58383:107;58331:159;;:::o;51712:167::-;51846:23;;;51792:4;47064:19;;;:12;;;:19;;;;;;:24;;51816:55;46967:129;14:196:1;82:20;;142:42;131:54;;121:65;;111:93;;200:1;197;190:12;111:93;14:196;;;:::o;215:186::-;274:6;327:2;315:9;306:7;302:23;298:32;295:52;;;343:1;340;333:12;295:52;366:29;385:9;366:29;:::i;598:607::-;710:4;739:2;768;757:9;750:21;800:6;794:13;843:6;838:2;827:9;823:18;816:34;868:1;878:140;892:6;889:1;886:13;878:140;;;987:14;;;983:23;;977:30;953:17;;;972:2;949:26;942:66;907:10;;878:140;;;882:3;1067:1;1062:2;1053:6;1042:9;1038:22;1034:31;1027:42;1196:2;1126:66;1121:2;1113:6;1109:15;1105:88;1094:9;1090:104;1086:113;1078:121;;;;598:607;;;;:::o;1210:254::-;1278:6;1286;1339:2;1327:9;1318:7;1314:23;1310:32;1307:52;;;1355:1;1352;1345:12;1307:52;1378:29;1397:9;1378:29;:::i;:::-;1368:39;1454:2;1439:18;;;;1426:32;;-1:-1:-1;;;1210:254:1:o;1651:328::-;1728:6;1736;1744;1797:2;1785:9;1776:7;1772:23;1768:32;1765:52;;;1813:1;1810;1803:12;1765:52;1836:29;1855:9;1836:29;:::i;:::-;1826:39;;1884:38;1918:2;1907:9;1903:18;1884:38;:::i;:::-;1874:48;;1969:2;1958:9;1954:18;1941:32;1931:42;;1651:328;;;;;:::o;2173:615::-;2259:6;2267;2320:2;2308:9;2299:7;2295:23;2291:32;2288:52;;;2336:1;2333;2326:12;2288:52;2376:9;2363:23;2405:18;2446:2;2438:6;2435:14;2432:34;;;2462:1;2459;2452:12;2432:34;2500:6;2489:9;2485:22;2475:32;;2545:7;2538:4;2534:2;2530:13;2526:27;2516:55;;2567:1;2564;2557:12;2516:55;2607:2;2594:16;2633:2;2625:6;2622:14;2619:34;;;2649:1;2646;2639:12;2619:34;2702:7;2697:2;2687:6;2684:1;2680:14;2676:2;2672:23;2668:32;2665:45;2662:65;;;2723:1;2720;2713:12;2662:65;2754:2;2746:11;;;;;2776:6;;-1:-1:-1;2173:615:1;;-1:-1:-1;;;;2173:615:1:o;3024:260::-;3092:6;3100;3153:2;3141:9;3132:7;3128:23;3124:32;3121:52;;;3169:1;3166;3159:12;3121:52;3192:29;3211:9;3192:29;:::i;:::-;3182:39;;3240:38;3274:2;3263:9;3259:18;3240:38;:::i;:::-;3230:48;;3024:260;;;;;:::o;3289:437::-;3368:1;3364:12;;;;3411;;;3432:61;;3486:4;3478:6;3474:17;3464:27;;3432:61;3539:2;3531:6;3528:14;3508:18;3505:38;3502:218;;3576:77;3573:1;3566:88;3677:4;3674:1;3667:15;3705:4;3702:1;3695:15;3502:218;;3289:437;;;:::o;3731:184::-;3783:77;3780:1;3773:88;3880:4;3877:1;3870:15;3904:4;3901:1;3894:15;3920:125;3985:9;;;4006:10;;;4003:36;;;4019:18;;:::i;4753:184::-;4805:77;4802:1;4795:88;4902:4;4899:1;4892:15;4926:4;4923:1;4916:15;4942:195;4981:3;5012:66;5005:5;5002:77;4999:103;;5082:18;;:::i;:::-;-1:-1:-1;5129:1:1;5118:13;;4942:195::o;10893:128::-;10960:9;;;10981:11;;;10978:37;;;10995:18;;:::i;11026:184::-;11078:77;11075:1;11068:88;11175:4;11172:1;11165:15;11199:4;11196:1;11189:15

ipfs://e936e1e4dd39271d793715068cd9204682cea3fabd16978fa1f4caa0c3115761