Token

CasinoDAO Fraction (CDAO-FRACTION)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

2,500 CDAO-FRACTION

Holders

473

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xeb248e38ec67dbe9cc3dc82bb5ed6d1681939cd8

Filtered by Token Holder

0xc3AABaA6331f170529Bdfd335bDeFbD1956AffFd

Balance

1 CDAO-FRACTION

0xc3aabaa6331f170529bdfd335bdefbd1956afffd

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

CasinoDAOFraction

Compiler Version

v0.8.22+commit.4fc1097e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-01-19
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}

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

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


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/access/Ownable.sol


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

pragma solidity ^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() {
        _transferOwnership(_msgSender());
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

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


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

pragma solidity ^0.8.1;

/**
 * @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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/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.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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


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

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/token/ERC721/IERC721.sol


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

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol


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

pragma solidity ^0.8.0;








/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: address zero is not a valid owner");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _ownerOf(tokenId);
        require(owner != address(0), "ERC721: invalid token ID");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        _requireMinted(tokenId);

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overridden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not token owner or approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
        _safeTransfer(from, to, tokenId, data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
     */
    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
        return _owners[tokenId];
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _ownerOf(tokenId) != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender);
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId, 1);

        // Check that tokenId was not minted by `_beforeTokenTransfer` hook
        require(!_exists(tokenId), "ERC721: token already minted");

        unchecked {
            // Will not overflow unless all 2**256 token ids are minted to the same owner.
            // Given that tokens are minted one by one, it is impossible in practice that
            // this ever happens. Might change if we allow batch minting.
            // The ERC fails to describe this case.
            _balances[to] += 1;
        }

        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId, 1);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     * This is an internal function that does not check if the sender is authorized to operate on the token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId, 1);

        // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook
        owner = ERC721.ownerOf(tokenId);

        // Clear approvals
        delete _tokenApprovals[tokenId];

        unchecked {
            // Cannot overflow, as that would require more tokens to be burned/transferred
            // out than the owner initially received through minting and transferring in.
            _balances[owner] -= 1;
        }
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId, 1);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId, 1);

        // Check that tokenId was not transferred by `_beforeTokenTransfer` hook
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");

        // Clear approvals from the previous owner
        delete _tokenApprovals[tokenId];

        unchecked {
            // `_balances[from]` cannot overflow for the same reason as described in `_burn`:
            // `from`'s balance is the number of token held, which is at least one before the current
            // transfer.
            // `_balances[to]` could overflow in the conditions described in `_mint`. That would require
            // all 2**256 token ids to be minted, which in practice is impossible.
            _balances[from] -= 1;
            _balances[to] += 1;
        }
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId, 1);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`.
     * - When `from` is zero, the tokens will be minted for `to`.
     * - When `to` is zero, ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is
     * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`.
     * - When `from` is zero, the tokens were minted for `to`.
     * - When `to` is zero, ``from``'s tokens were burned.
     * - `from` and `to` are never both zero.
     * - `batchSize` is non-zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 firstTokenId, uint256 batchSize) internal virtual {}

    /**
     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
     *
     * WARNING: Anyone calling this MUST ensure that the balances remain consistent with the ownership. The invariant
     * being that for any address `a` the value returned by `balanceOf(a)` must be equal to the number of tokens such
     * that `ownerOf(tokenId)` is `a`.
     */
    // solhint-disable-next-line func-name-mixedcase
    function __unsafe_increaseBalance(address account, uint256 amount) internal {
        _balances[account] += amount;
    }
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol)

pragma solidity ^0.8.0;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) {
        return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 firstTokenId,
        uint256 batchSize
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, firstTokenId, batchSize);

        if (batchSize > 1) {
            // Will only trigger during construction. Batch transferring (minting) is not available afterwards.
            revert("ERC721Enumerable: consecutive transfers not supported");
        }

        uint256 tokenId = firstTokenId;

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

// File: contracts/CasinoDAOFractionNFT.sol


pragma solidity ^0.8.18;





contract CasinoDAOFraction is ERC721Enumerable, Ownable, ReentrancyGuard {

    using Strings for uint256;

    string public baseURI;
    bool public pauseMinting = true;

    address public premintAddr;
    bool public premintExecuted = false;

    uint256 private immutable maxSupply = 2500;
    uint256 public mintWindow = 12 hours;
    uint256 public salesPeriod = 24 hours;
    uint256 public transferLockPeriod = 48 hours;

    uint256 public wlStart = 1706101200;
    uint256 public maxWhitelistMintPerWallet = 2;
    uint256 public wlPrice = 0.06 ether;
    uint256 public wlMinted;

    uint256 public maxMintPerWallet = 2;
    uint256 public mintPrice = 0.1 ether;
    uint256 public minted;

    mapping(address => bool) public admin;
    mapping(address => bool) public verifiedContract;
    mapping(address => bool) public whitelisted;
    mapping(address => uint256) public whitelistMinted;
    mapping(address => uint256) public walletMinted;

    event WhitelistMinted(address minter, uint256 mintQuantity);
    event Minted(address minter, uint256 mintQuantity);

    constructor(
        string memory _initBaseURI
    ) ERC721("CasinoDAO Fraction", "CDAO-FRACTION") {
        baseURI = _initBaseURI;
        _safeMint(msg.sender, minted + 1);
        minted += 1;
    }

    function premint() external onlyOwner {
        require(premintAddr != address(0), "Cannot premint for null address.");
        require(!premintExecuted, "Premint already executed.");
        for (uint256 i = 0; i < 199; i++) {
            _safeMint(premintAddr, minted + 1);
        }
        minted += 199;
        premintExecuted = true;
    }

    function whitlistMint(uint256 _quantity) external payable nonReentrant {
        require(!pauseMinting, "Minting is paused.");
        require(block.timestamp >= wlStart, "Whitelist mint not yet start.");
        require(block.timestamp <= wlStart + mintWindow, "Whitelist mint ended.");
        require(whitelisted[msg.sender], "Caller is not whitelisted.");
        require(_quantity > 0, "Invalid quantity.");
        require(_quantity <= maxWhitelistMintPerWallet, "Exceed max whitelist mint quantity.");
        require(whitelistMinted[msg.sender] + _quantity <= maxWhitelistMintPerWallet, "Exceed max mint per whitelist.");
        require(wlMinted + _quantity <= maxSupply, "CasinoDAO NFT is minted out.");
        require(msg.value >= wlPrice * _quantity, "Transaction underpriced.");
        for (uint256 i = 0; i < _quantity; i++) {
            _safeMint(msg.sender, minted + 1);
            whitelistMinted[msg.sender]++;
            wlMinted++;
            minted++;
        }
        emit WhitelistMinted(msg.sender, _quantity);
    }

    function publicMint(uint256 _quantity) external payable nonReentrant {
        require(!pauseMinting, "Minting is paused.");
        require(block.timestamp >= wlStart + mintWindow, "Public mint not yet start.");
        require(_quantity > 0, "Invalid quantity.");
        require(_quantity <= maxMintPerWallet, "Exceed max quantity.");
        require(walletMinted[msg.sender] + _quantity <= maxMintPerWallet, "Exceed max mint per wallet.");
        require(minted + _quantity <= maxSupply, "CasinoDAO NFT is minted out.");
        require(msg.value >= mintPrice * _quantity, "Transaction underpriced.");
        for (uint256 i = 0; i < _quantity; i++) {
            _safeMint(msg.sender, minted + 1);
            walletMinted[msg.sender]++;
            minted++;
        }
        emit Minted(msg.sender, _quantity);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override(ERC721, IERC721) {
        if (msg.sender != premintAddr) {
            require(block.timestamp >= wlStart + transferLockPeriod, "Transfer locked for 48 hours.");
        }
        super.safeTransferFrom(from, to, tokenId);
    }

    function transferFrom(address from, address to, uint256 tokenId) public virtual override(ERC721, IERC721) {
        if (msg.sender != premintAddr) {
            require(block.timestamp >= wlStart + transferLockPeriod, "Transfer locked for 48 hours.");
        }
        super.transferFrom(from, to, tokenId);
    }

    function contractSales(address receiver, uint256 _quantity) public {
        require(verifiedContract[msg.sender], "Caller is not a verified contract.");
        require(_quantity > 0, "Invalid quantity.");
        require(minted + _quantity <= maxSupply, "NFT is minted out.");
        for (uint256 i = 0; i < _quantity; i++) {
            _safeMint(receiver, minted + 1);
            minted++;
        }
    }

    function tokensOwnedByAddress(address _owner) public view returns (uint256[] memory) {
        uint256 ownerTokenCount = balanceOf(_owner);
        uint256[] memory tokenIds = new uint256[](ownerTokenCount);
        for (uint256 i; i < ownerTokenCount; i++) {
            tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
        }
        return tokenIds;
    }

    function _baseURI() internal view virtual override returns (string memory) {
        return baseURI;
    }

    function checkWhitelist(address _wallet) public view returns (bool) {
        return whitelisted[_wallet];
    }

    function toggleMinting(bool _state) external {
        require(admin[msg.sender] || msg.sender == owner(), "Only admin or owner can execute.");
        pauseMinting = _state;
    }

    function updateWhitelistPrice(uint256 _newPrice) external {
        require(admin[msg.sender] || msg.sender == owner(), "Only admin or owner can execute.");
        wlPrice = _newPrice;
    }

    function updateMintPrice(uint256 _newPrice) external {
        require(admin[msg.sender] || msg.sender == owner(), "Only admin or owner can execute.");
        mintPrice = _newPrice;
    }

    function addWhitelist(address[] memory _wlWallet) external {
        require(admin[msg.sender] || msg.sender == owner(), "Only admin or owner can execute.");
        for (uint256 i = 0; i < _wlWallet.length; i++) {
            whitelisted[_wlWallet[i]] = true;
        }
    }

    function removeWhitelist(address[] memory _wlWallet) external {
        require(admin[msg.sender] || msg.sender == owner(), "Only admin or owner can execute.");
        for (uint256 i = 0; i < _wlWallet.length; i++) {
            whitelisted[_wlWallet[i]] = false;
        }
    }

    function setBaseURI(string memory _newBaseURI) public onlyOwner {
        baseURI = _newBaseURI;
    }

    function manageAdmin(address wallet, bool _state) external onlyOwner {
        admin[wallet] = _state;
    }

    function manageContract(address contractAddress, bool _state) external onlyOwner {
        verifiedContract[contractAddress] = _state;
    }

    function setPremintAddr(address _premintWallet) external onlyOwner {
        premintAddr = _premintWallet;
    }

    function withdrawSales() external onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "Contract insufficient balance.");
	    (bool success, ) = payable(owner()).call{value: address(this).balance}("");
		require(success);
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_initBaseURI","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"mintQuantity","type":"uint256"}],"name":"Minted","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":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"mintQuantity","type":"uint256"}],"name":"WhitelistMinted","type":"event"},{"inputs":[{"internalType":"address[]","name":"_wlWallet","type":"address[]"}],"name":"addWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"admin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_wallet","type":"address"}],"name":"checkWhitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"contractSales","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"},{"internalType":"bool","name":"_state","type":"bool"}],"name":"manageAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"},{"internalType":"bool","name":"_state","type":"bool"}],"name":"manageContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxMintPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWhitelistMintPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintWindow","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseMinting","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"premint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"premintAddr","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"premintExecuted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_wlWallet","type":"address[]"}],"name":"removeWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"salesPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_premintWallet","type":"address"}],"name":"setPremintAddr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"toggleMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOwnedByAddress","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"transferLockPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPrice","type":"uint256"}],"name":"updateMintPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newPrice","type":"uint256"}],"name":"updateWhitelistPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"verifiedContract","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"walletMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_quantity","type":"uint256"}],"name":"whitlistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"withdrawSales","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wlMinted","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wlPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wlStart","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000002b68747470733a2f2f63646e2e636173696e6f64616f2e696f2f6e66742f6672616374696f6e2f6a736f6e2f000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _initBaseURI (string): https://cdn.casinodao.io/nft/fraction/json/

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000020
Arg [1] : 000000000000000000000000000000000000000000000000000000000000002b
Arg [2] : 68747470733a2f2f63646e2e636173696e6f64616f2e696f2f6e66742f667261
Arg [3] : 6374696f6e2f6a736f6e2f000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

68005:7268:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73715:191;;;;;;;;;;-1:-1:-1;73715:191:0;;;;;:::i;:::-;;:::i;:::-;;61985:224;;;;;;;;;;-1:-1:-1;61985:224:0;;;;;:::i;:::-;;:::i;:::-;;;750:14:1;;743:22;725:41;;713:2;698:18;61985:224:0;;;;;;;;72284:419;;;;;;;;;;-1:-1:-1;72284:419:0;;;;;:::i;:::-;;:::i;68455:35::-;;;;;;;;;;;;;;;;;;;1360:25:1;;;1348:2;1333:18;68455:35:0;1214:177:1;46034:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;47546:171::-;;;;;;;;;;-1:-1:-1;47546:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2316:32:1;;;2298:51;;2286:2;2271:18;47546:171:0;2152:203:1;47064:416:0;;;;;;;;;;-1:-1:-1;47064:416:0;;;;;:::i;:::-;;:::i;62625:113::-;;;;;;;;;;-1:-1:-1;62713:10:0;:17;62625:113;;73200:114;;;;;;;;;;-1:-1:-1;73200:114:0;;;;;:::i;:::-;-1:-1:-1;;;;;73286:20:0;73262:4;73286:20;;;:11;:20;;;;;;;;;73200:114;73322:183;;;;;;;;;;-1:-1:-1;73322:183:0;;;;;:::i;:::-;;:::i;74203:285::-;;;;;;;;;;-1:-1:-1;74203:285:0;;;;;:::i;:::-;;:::i;71957:319::-;;;;;;;;;;-1:-1:-1;71957:319:0;;;;;:::i;:::-;;:::i;70775:839::-;;;;;;:::i;:::-;;:::i;62293:256::-;;;;;;;;;;-1:-1:-1;62293:256:0;;;;;:::i;:::-;;:::i;74998:270::-;;;;;;;;;;;;;:::i;71622:327::-;;;;;;;;;;-1:-1:-1;71622:327:0;;;;;:::i;:::-;;:::i;68590:23::-;;;;;;;;;;;;;;;;69341:354;;;;;;;;;;;;;:::i;74876:114::-;;;;;;;;;;-1:-1:-1;74876:114:0;;;;;:::i;:::-;;:::i;68707:21::-;;;;;;;;;;;;;;;;62815:233;;;;;;;;;;-1:-1:-1;62815:233:0;;;;;:::i;:::-;;:::i;74496:104::-;;;;;;;;;;-1:-1:-1;74496:104:0;;;;;:::i;:::-;;:::i;68402:44::-;;;;;;;;;;;;;;;;45744:223;;;;;;;;;;-1:-1:-1;45744:223:0;;;;;:::i;:::-;;:::i;68737:37::-;;;;;;;;;;-1:-1:-1;68737:37:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;74608:110;;;;;;;;;;-1:-1:-1;74608:110:0;;;;;:::i;:::-;;:::i;68664:36::-;;;;;;;;;;;;;;;;68121:21;;;;;;;;;;;;;:::i;45475:207::-;;;;;;;;;;-1:-1:-1;45475:207:0;;;;;:::i;:::-;;:::i;23364:103::-;;;;;;;;;;;;;:::i;68781:48::-;;;;;;;;;;-1:-1:-1;68781:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;22723:87;;;;;;;;;;-1:-1:-1;22796:6:0;;-1:-1:-1;;;;;22796:6:0;22723:87;;46203:104;;;;;;;;;;;;;:::i;68886:50::-;;;;;;;;;;-1:-1:-1;68886:50:0;;;;;:::i;:::-;;;;;;;;;;;;;;68358:37;;;;;;;;;;;;;;;;68315:36;;;;;;;;;;;;;;;;47789:155;;;;;;;;;;-1:-1:-1;47789:155:0;;;;;:::i;:::-;;:::i;73513:194::-;;;;;;;;;;-1:-1:-1;73513:194:0;;;;;:::i;:::-;;:::i;68622:35::-;;;;;;;;;;;;;;;;68497:44;;;;;;;;;;;;;;;;69703:1064;;;;;;:::i;:::-;;:::i;48840:279::-;;;;;;;;;;-1:-1:-1;48840:279:0;;;;;:::i;:::-;;:::i;72711:365::-;;;;;;;;;;-1:-1:-1;72711:365:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;68548:35::-;;;;;;;;;;;;;;;;46378:281;;;;;;;;;;-1:-1:-1;46378:281:0;;;;;:::i;:::-;;:::i;68943:47::-;;;;;;;;;;-1:-1:-1;68943:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;68836:43;;;;;;;;;;-1:-1:-1;68836:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;68149:31;;;;;;;;;;-1:-1:-1;68149:31:0;;;;;;;;68222:35;;;;;;;;;;-1:-1:-1;68222:35:0;;;;-1:-1:-1;;;68222:35:0;;;;;;48015:164;;;;;;;;;;-1:-1:-1;48015:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;48136:25:0;;;48112:4;48136:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;48015:164;73914:281;;;;;;;;;;-1:-1:-1;73914:281:0;;;;;:::i;:::-;;:::i;23622:201::-;;;;;;;;;;-1:-1:-1;23622:201:0;;;;;:::i;:::-;;:::i;68189:26::-;;;;;;;;;;-1:-1:-1;68189:26:0;;;;;;;-1:-1:-1;;;;;68189:26:0;;;74726:142;;;;;;;;;;-1:-1:-1;74726:142:0;;;;;:::i;:::-;;:::i;73715:191::-;73793:10;73787:17;;;;:5;:17;;;;;;;;;:42;;-1:-1:-1;22796:6:0;;-1:-1:-1;;;;;22796:6:0;73808:10;:21;73787:42;73779:87;;;;-1:-1:-1;;;73779:87:0;;;;;;;:::i;:::-;;;;;;;;;73877:9;:21;73715:191::o;61985:224::-;62087:4;-1:-1:-1;;;;;;62111:50:0;;-1:-1:-1;;;62111:50:0;;:90;;;62165:36;62189:11;62165:23;:36::i;:::-;62104:97;61985:224;-1:-1:-1;;61985:224:0:o;72284:419::-;72387:10;72370:28;;;;:16;:28;;;;;;;;72362:75;;;;-1:-1:-1;;;72362:75:0;;7867:2:1;72362:75:0;;;7849:21:1;7906:2;7886:18;;;7879:30;7945:34;7925:18;;;7918:62;-1:-1:-1;;;7996:18:1;;;7989:32;8038:19;;72362:75:0;7665:398:1;72362:75:0;72468:1;72456:9;:13;72448:43;;;;-1:-1:-1;;;72448:43:0;;;;;;;:::i;:::-;72532:9;72519;72510:6;;:18;;;;:::i;:::-;:31;;72502:62;;;;-1:-1:-1;;;72502:62:0;;8878:2:1;72502:62:0;;;8860:21:1;8917:2;8897:18;;;8890:30;-1:-1:-1;;;8936:18:1;;;8929:48;8994:18;;72502:62:0;8676:342:1;72502:62:0;72580:9;72575:121;72599:9;72595:1;:13;72575:121;;;72630:31;72640:8;72650:6;;72659:1;72650:10;;;;:::i;:::-;72630:9;:31::i;:::-;72676:6;:8;;;:6;:8;;;:::i;:::-;;;;-1:-1:-1;;72610:3:0;;72575:121;;;;72284:419;;:::o;46034:100::-;46088:13;46121:5;46114:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46034:100;:::o;47546:171::-;47622:7;47642:23;47657:7;47642:14;:23::i;:::-;-1:-1:-1;47685:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;47685:24:0;;47546:171::o;47064:416::-;47145:13;47161:23;47176:7;47161:14;:23::i;:::-;47145:39;;47209:5;-1:-1:-1;;;;;47203:11:0;:2;-1:-1:-1;;;;;47203:11:0;;47195:57;;;;-1:-1:-1;;;47195:57:0;;9750:2:1;47195:57:0;;;9732:21:1;9789:2;9769:18;;;9762:30;9828:34;9808:18;;;9801:62;-1:-1:-1;;;9879:18:1;;;9872:31;9920:19;;47195:57:0;9548:397:1;47195:57:0;21354:10;-1:-1:-1;;;;;47287:21:0;;;;:62;;-1:-1:-1;47312:37:0;47329:5;21354:10;48015:164;:::i;47312:37::-;47265:173;;;;-1:-1:-1;;;47265:173:0;;10152:2:1;47265:173:0;;;10134:21:1;10191:2;10171:18;;;10164:30;10230:34;10210:18;;;10203:62;10301:31;10281:18;;;10274:59;10350:19;;47265:173:0;9950:425:1;47265:173:0;47451:21;47460:2;47464:7;47451:8;:21::i;73322:183::-;73392:10;73386:17;;;;:5;:17;;;;;;;;;:42;;-1:-1:-1;22796:6:0;;-1:-1:-1;;;;;22796:6:0;73407:10;:21;73386:42;73378:87;;;;-1:-1:-1;;;73378:87:0;;;;;;;:::i;:::-;73476:12;:21;;-1:-1:-1;;73476:21:0;;;;;;;;;;73322:183::o;74203:285::-;74290:10;74284:17;;;;:5;:17;;;;;;;;;:42;;-1:-1:-1;22796:6:0;;-1:-1:-1;;;;;22796:6:0;74305:10;:21;74284:42;74276:87;;;;-1:-1:-1;;;74276:87:0;;;;;;;:::i;:::-;74379:9;74374:107;74398:9;:16;74394:1;:20;74374:107;;;74464:5;74436:11;:25;74448:9;74458:1;74448:12;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;74436:25:0;;;;;;;;;;;-1:-1:-1;74436:25:0;:33;;-1:-1:-1;;74436:33:0;;;;;;;;;;-1:-1:-1;74416:3:0;74374:107;;;;74203:285;:::o;71957:319::-;72092:11;;;;;-1:-1:-1;;;;;72092:11:0;72078:10;:25;72074:147;;72157:18;;72147:7;;:28;;;;:::i;:::-;72128:15;:47;;72120:89;;;;-1:-1:-1;;;72120:89:0;;10714:2:1;72120:89:0;;;10696:21:1;10753:2;10733:18;;;10726:30;10792:31;10772:18;;;10765:59;10841:18;;72120:89:0;10512:353:1;72120:89:0;72231:37;72250:4;72256:2;72260:7;72231:18;:37::i;70775:839::-;2378:21;:19;:21::i;:::-;70864:12:::1;::::0;::::1;;70863:13;70855:44;;;::::0;-1:-1:-1;;;70855:44:0;;11072:2:1;70855:44:0::1;::::0;::::1;11054:21:1::0;11111:2;11091:18;;;11084:30;-1:-1:-1;;;11130:18:1;;;11123:48;11188:18;;70855:44:0::1;10870:342:1::0;70855:44:0::1;70947:10;;70937:7;;:20;;;;:::i;:::-;70918:15;:39;;70910:78;;;::::0;-1:-1:-1;;;70910:78:0;;11419:2:1;70910:78:0::1;::::0;::::1;11401:21:1::0;11458:2;11438:18;;;11431:30;11497:28;11477:18;;;11470:56;11543:18;;70910:78:0::1;11217:350:1::0;70910:78:0::1;71019:1;71007:9;:13;70999:43;;;;-1:-1:-1::0;;;70999:43:0::1;;;;;;;:::i;:::-;71074:16;;71061:9;:29;;71053:62;;;::::0;-1:-1:-1;;;71053:62:0;;11774:2:1;71053:62:0::1;::::0;::::1;11756:21:1::0;11813:2;11793:18;;;11786:30;-1:-1:-1;;;11832:18:1;;;11825:50;11892:18;;71053:62:0::1;11572:344:1::0;71053:62:0::1;71174:16;::::0;71147:10:::1;71134:24;::::0;;;:12:::1;:24;::::0;;;;;:36:::1;::::0;71161:9;;71134:36:::1;:::i;:::-;:56;;71126:96;;;::::0;-1:-1:-1;;;71126:96:0;;12123:2:1;71126:96:0::1;::::0;::::1;12105:21:1::0;12162:2;12142:18;;;12135:30;12201:29;12181:18;;;12174:57;12248:18;;71126:96:0::1;11921:351:1::0;71126:96:0::1;71263:9;71250;71241:6;;:18;;;;:::i;:::-;:31;;71233:72;;;::::0;-1:-1:-1;;;71233:72:0;;12479:2:1;71233:72:0::1;::::0;::::1;12461:21:1::0;12518:2;12498:18;;;12491:30;12557;12537:18;;;12530:58;12605:18;;71233:72:0::1;12277:352:1::0;71233:72:0::1;71349:9;71337;;:21;;;;:::i;:::-;71324:9;:34;;71316:71;;;::::0;-1:-1:-1;;;71316:71:0;;13009:2:1;71316:71:0::1;::::0;::::1;12991:21:1::0;13048:2;13028:18;;;13021:30;-1:-1:-1;;;13067:18:1;;;13060:54;13131:18;;71316:71:0::1;12807:348:1::0;71316:71:0::1;71403:9;71398:164;71422:9;71418:1;:13;71398:164;;;71453:33;71463:10;71475:6;;71484:1;71475:10;;;;:::i;71453:33::-;71514:10;71501:24;::::0;;;:12:::1;:24;::::0;;;;:26;;;::::1;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;71542:6:0::1;:8:::0;;;:6:::1;:8;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;71433:3:0::1;;71398:164;;;-1:-1:-1::0;71577:29:0::1;::::0;;71584:10:::1;13334:51:1::0;;13416:2;13401:18;;13394:34;;;71577:29:0::1;::::0;13307:18:1;71577:29:0::1;;;;;;;;2422:20:::0;1816:1;2942:7;:22;2759:213;2422:20;70775:839;:::o;62293:256::-;62390:7;62426:23;62443:5;62426:16;:23::i;:::-;62418:5;:31;62410:87;;;;-1:-1:-1;;;62410:87:0;;13641:2:1;62410:87:0;;;13623:21:1;13680:2;13660:18;;;13653:30;13719:34;13699:18;;;13692:62;-1:-1:-1;;;13770:18:1;;;13763:41;13821:19;;62410:87:0;13439:407:1;62410:87:0;-1:-1:-1;;;;;;62515:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;62293:256::o;74998:270::-;22609:13;:11;:13::i;:::-;75071:21:::1;75111:11:::0;75103:54:::1;;;::::0;-1:-1:-1;;;75103:54:0;;14053:2:1;75103:54:0::1;::::0;::::1;14035:21:1::0;14092:2;14072:18;;;14065:30;14131:32;14111:18;;;14104:60;14181:18;;75103:54:0::1;13851:354:1::0;75103:54:0::1;75166:12;75192:7;22796:6:::0;;-1:-1:-1;;;;;22796:6:0;;22723:87;75192:7:::1;-1:-1:-1::0;;;;;75184:21:0::1;75213;75184:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;75165:74;;;75252:7;75244:16;;;::::0;::::1;71622:327:::0;71761:11;;;;;-1:-1:-1;;;;;71761:11:0;71747:10;:25;71743:147;;71826:18;;71816:7;;:28;;;;:::i;:::-;71797:15;:47;;71789:89;;;;-1:-1:-1;;;71789:89:0;;10714:2:1;71789:89:0;;;10696:21:1;10753:2;10733:18;;;10726:30;10792:31;10772:18;;;10765:59;10841:18;;71789:89:0;10512:353:1;71789:89:0;71900:41;71923:4;71929:2;71933:7;71900:22;:41::i;69341:354::-;22609:13;:11;:13::i;:::-;69398:11:::1;::::0;::::1;::::0;::::1;-1:-1:-1::0;;;;;69398:11:0::1;69390:70;;;::::0;-1:-1:-1;;;69390:70:0;;14622:2:1;69390:70:0::1;::::0;::::1;14604:21:1::0;;;14641:18;;;14634:30;14700:34;14680:18;;;14673:62;14752:18;;69390:70:0::1;14420:356:1::0;69390:70:0::1;69480:15;::::0;-1:-1:-1;;;69480:15:0;::::1;;;69479:16;69471:54;;;::::0;-1:-1:-1;;;69471:54:0;;14983:2:1;69471:54:0::1;::::0;::::1;14965:21:1::0;15022:2;15002:18;;;14995:30;15061:27;15041:18;;;15034:55;15106:18;;69471:54:0::1;14781:349:1::0;69471:54:0::1;69541:9;69536:95;69560:3;69556:1;:7;69536:95;;;69595:11;::::0;69608:6:::1;::::0;69585:34:::1;::::0;69595:11:::1;::::0;::::1;-1:-1:-1::0;;;;;69595:11:0::1;::::0;69608:10:::1;::::0;69595:11:::1;69608:10;:::i;69585:34::-;69565:3;;69536:95;;;;69651:3;69641:6;;:13;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;69665:15:0::1;:22:::0;;-1:-1:-1;;;;69665:22:0::1;-1:-1:-1::0;;;69665:22:0::1;::::0;;69341:354::o;74876:114::-;22609:13;:11;:13::i;:::-;74954:11:::1;:28:::0;;-1:-1:-1;;;;;74954:28:0;;::::1;;;-1:-1:-1::0;;;;;;74954:28:0;;::::1;::::0;;;::::1;::::0;;74876:114::o;62815:233::-;62890:7;62926:30;62713:10;:17;;62625:113;62926:30;62918:5;:38;62910:95;;;;-1:-1:-1;;;62910:95:0;;15337:2:1;62910:95:0;;;15319:21:1;15376:2;15356:18;;;15349:30;15415:34;15395:18;;;15388:62;-1:-1:-1;;;15466:18:1;;;15459:42;15518:19;;62910:95:0;15135:408:1;62910:95:0;63023:10;63034:5;63023:17;;;;;;;;:::i;:::-;;;;;;;;;63016:24;;62815:233;;;:::o;74496:104::-;22609:13;:11;:13::i;:::-;74571:7:::1;:21;74581:11:::0;74571:7;:21:::1;:::i;45744:223::-:0;45816:7;50477:16;;;:7;:16;;;;;;-1:-1:-1;;;;;50477:16:0;;45880:56;;;;-1:-1:-1;;;45880:56:0;;17920:2:1;45880:56:0;;;17902:21:1;17959:2;17939:18;;;17932:30;-1:-1:-1;;;17978:18:1;;;17971:54;18042:18;;45880:56:0;17718:348:1;74608:110:0;22609:13;:11;:13::i;:::-;-1:-1:-1;;;;;74688:13:0;;;::::1;;::::0;;;:5:::1;:13;::::0;;;;:22;;-1:-1:-1;;74688:22:0::1;::::0;::::1;;::::0;;;::::1;::::0;;74608:110::o;68121:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;45475:207::-;45547:7;-1:-1:-1;;;;;45575:19:0;;45567:73;;;;-1:-1:-1;;;45567:73:0;;18273:2:1;45567:73:0;;;18255:21:1;18312:2;18292:18;;;18285:30;18351:34;18331:18;;;18324:62;-1:-1:-1;;;18402:18:1;;;18395:39;18451:19;;45567:73:0;18071:405:1;45567:73:0;-1:-1:-1;;;;;;45658:16:0;;;;;:9;:16;;;;;;;45475:207::o;23364:103::-;22609:13;:11;:13::i;:::-;23429:30:::1;23456:1;23429:18;:30::i;:::-;23364:103::o:0;46203:104::-;46259:13;46292:7;46285:14;;;;;:::i;47789:155::-;47884:52;21354:10;47917:8;47927;47884:18;:52::i;73513:194::-;73596:10;73590:17;;;;:5;:17;;;;;;;;;:42;;-1:-1:-1;22796:6:0;;-1:-1:-1;;;;;22796:6:0;73611:10;:21;73590:42;73582:87;;;;-1:-1:-1;;;73582:87:0;;;;;;;:::i;:::-;73680:7;:19;73513:194::o;69703:1064::-;2378:21;:19;:21::i;:::-;69794:12:::1;::::0;::::1;;69793:13;69785:44;;;::::0;-1:-1:-1;;;69785:44:0;;11072:2:1;69785:44:0::1;::::0;::::1;11054:21:1::0;11111:2;11091:18;;;11084:30;-1:-1:-1;;;11130:18:1;;;11123:48;11188:18;;69785:44:0::1;10870:342:1::0;69785:44:0::1;69867:7;;69848:15;:26;;69840:68;;;::::0;-1:-1:-1;;;69840:68:0;;18683:2:1;69840:68:0::1;::::0;::::1;18665:21:1::0;18722:2;18702:18;;;18695:30;18761:31;18741:18;;;18734:59;18810:18;;69840:68:0::1;18481:353:1::0;69840:68:0::1;69956:10;;69946:7;;:20;;;;:::i;:::-;69927:15;:39;;69919:73;;;::::0;-1:-1:-1;;;69919:73:0;;19041:2:1;69919:73:0::1;::::0;::::1;19023:21:1::0;19080:2;19060:18;;;19053:30;-1:-1:-1;;;19099:18:1;;;19092:51;19160:18;;69919:73:0::1;18839:345:1::0;69919:73:0::1;70023:10;70011:23;::::0;;;:11:::1;:23;::::0;;;;;::::1;;70003:62;;;::::0;-1:-1:-1;;;70003:62:0;;19391:2:1;70003:62:0::1;::::0;::::1;19373:21:1::0;19430:2;19410:18;;;19403:30;19469:28;19449:18;;;19442:56;19515:18;;70003:62:0::1;19189:350:1::0;70003:62:0::1;70096:1;70084:9;:13;70076:43;;;;-1:-1:-1::0;;;70076:43:0::1;;;;;;;:::i;:::-;70151:25;;70138:9;:38;;70130:86;;;::::0;-1:-1:-1;;;70130:86:0;;19746:2:1;70130:86:0::1;::::0;::::1;19728:21:1::0;19785:2;19765:18;;;19758:30;19824:34;19804:18;;;19797:62;-1:-1:-1;;;19875:18:1;;;19868:33;19918:19;;70130:86:0::1;19544:399:1::0;70130:86:0::1;70278:25;::::0;70251:10:::1;70235:27;::::0;;;:15:::1;:27;::::0;;;;;:39:::1;::::0;70265:9;;70235:39:::1;:::i;:::-;:68;;70227:111;;;::::0;-1:-1:-1;;;70227:111:0;;20150:2:1;70227:111:0::1;::::0;::::1;20132:21:1::0;20189:2;20169:18;;;20162:30;20228:32;20208:18;;;20201:60;20278:18;;70227:111:0::1;19948:354:1::0;70227:111:0::1;70381:9;70368;70357:8;;:20;;;;:::i;:::-;:33;;70349:74;;;::::0;-1:-1:-1;;;70349:74:0;;12479:2:1;70349:74:0::1;::::0;::::1;12461:21:1::0;12518:2;12498:18;;;12491:30;12557;12537:18;;;12530:58;12605:18;;70349:74:0::1;12277:352:1::0;70349:74:0::1;70465:9;70455:7;;:19;;;;:::i;:::-;70442:9;:32;;70434:69;;;::::0;-1:-1:-1;;;70434:69:0;;13009:2:1;70434:69:0::1;::::0;::::1;12991:21:1::0;13048:2;13028:18;;;13021:30;-1:-1:-1;;;13067:18:1;;;13060:54;13131:18;;70434:69:0::1;12807:348:1::0;70434:69:0::1;70519:9;70514:192;70538:9;70534:1;:13;70514:192;;;70569:33;70579:10;70591:6;;70600:1;70591:10;;;;:::i;70569:33::-;70633:10;70617:27;::::0;;;:15:::1;:27;::::0;;;;:29;;;::::1;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;70661:8:0::1;:10:::0;;;:8:::1;:10;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;70686:6:0::1;:8:::0;;;:6:::1;:8;::::0;::::1;:::i;:::-;::::0;;;-1:-1:-1;;70549:3:0::1;;70514:192;;;-1:-1:-1::0;70721:38:0::1;::::0;;70737:10:::1;13334:51:1::0;;13416:2;13401:18;;13394:34;;;70721:38:0::1;::::0;13307:18:1;70721:38:0::1;13160:274:1::0;48840:279:0;48971:41;21354:10;49004:7;48971:18;:41::i;:::-;48963:99;;;;-1:-1:-1;;;48963:99:0;;;;;;;:::i;:::-;49073:38;49087:4;49093:2;49097:7;49106:4;49073:13;:38::i;:::-;48840:279;;;;:::o;72711:365::-;72778:16;72807:23;72833:17;72843:6;72833:9;:17::i;:::-;72807:43;;72861:25;72903:15;72889:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72889:30:0;;72861:58;;72935:9;72930:113;72950:15;72946:1;:19;72930:113;;;73001:30;73021:6;73029:1;73001:19;:30::i;:::-;72987:8;72996:1;72987:11;;;;;;;;:::i;:::-;;;;;;;;;;:44;72967:3;;72930:113;;;-1:-1:-1;73060:8:0;72711:365;-1:-1:-1;;;72711:365:0:o;46378:281::-;46451:13;46477:23;46492:7;46477:14;:23::i;:::-;46513:21;46537:10;:8;:10::i;:::-;46513:34;;46589:1;46571:7;46565:21;:25;:86;;;;;;;;;;;;;;;;;46617:7;46626:18;:7;:16;:18::i;:::-;46600:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;46565:86;46558:93;46378:281;-1:-1:-1;;;46378:281:0:o;73914:::-;73998:10;73992:17;;;;:5;:17;;;;;;;;;:42;;-1:-1:-1;22796:6:0;;-1:-1:-1;;;;;22796:6:0;74013:10;:21;73992:42;73984:87;;;;-1:-1:-1;;;73984:87:0;;;;;;;:::i;:::-;74087:9;74082:106;74106:9;:16;74102:1;:20;74082:106;;;74172:4;74144:11;:25;74156:9;74166:1;74156:12;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;74144:25:0;;;;;;;;;;;-1:-1:-1;74144:25:0;:32;;-1:-1:-1;;74144:32:0;;;;;;;;;;-1:-1:-1;74124:3:0;74082:106;;23622:201;22609:13;:11;:13::i;:::-;-1:-1:-1;;;;;23711:22:0;::::1;23703:73;;;::::0;-1:-1:-1;;;23703:73:0;;21424:2:1;23703:73:0::1;::::0;::::1;21406:21:1::0;21463:2;21443:18;;;21436:30;21502:34;21482:18;;;21475:62;-1:-1:-1;;;21553:18:1;;;21546:36;21599:19;;23703:73:0::1;21222:402:1::0;23703:73:0::1;23787:28;23806:8;23787:18;:28::i;74726:142::-:0;22609:13;:11;:13::i;:::-;-1:-1:-1;;;;;74818:33:0;;;::::1;;::::0;;;:16:::1;:33;::::0;;;;:42;;-1:-1:-1;;74818:42:0::1;::::0;::::1;;::::0;;;::::1;::::0;;74726:142::o;45106:305::-;45208:4;-1:-1:-1;;;;;;45245:40:0;;-1:-1:-1;;;45245:40:0;;:105;;-1:-1:-1;;;;;;;45302:48:0;;-1:-1:-1;;;45302:48:0;45245:105;:158;;;-1:-1:-1;;;;;;;;;;36759:40:0;;;45367:36;36650:157;51715:110;51791:26;51801:2;51805:7;51791:26;;;;;;;;;;;;:9;:26::i;57109:135::-;50879:4;50477:16;;;:7;:16;;;;;;-1:-1:-1;;;;;50477:16:0;57183:53;;;;-1:-1:-1;;;57183:53:0;;17920:2:1;57183:53:0;;;17902:21:1;17959:2;17939:18;;;17932:30;-1:-1:-1;;;17978:18:1;;;17971:54;18042:18;;57183:53:0;17718:348:1;56422:174:0;56497:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;56497:29:0;-1:-1:-1;;;;;56497:29:0;;;;;;;;:24;;56551:23;56497:24;56551:14;:23::i;:::-;-1:-1:-1;;;;;56542:46:0;;;;;;;;;;;56422:174;;:::o;48246:301::-;48407:41;21354:10;48440:7;48407:18;:41::i;:::-;48399:99;;;;-1:-1:-1;;;48399:99:0;;;;;;;:::i;:::-;48511:28;48521:4;48527:2;48531:7;48511:9;:28::i;2458:293::-;1860:1;2592:7;;:19;2584:63;;;;-1:-1:-1;;;2584:63:0;;21831:2:1;2584:63:0;;;21813:21:1;21870:2;21850:18;;;21843:30;21909:33;21889:18;;;21882:61;21960:18;;2584:63:0;21629:355:1;2584:63:0;1860:1;2725:7;:18;2458:293::o;22888:132::-;22796:6;;-1:-1:-1;;;;;22796:6:0;21354:10;22952:23;22944:68;;;;-1:-1:-1;;;22944:68:0;;22191:2:1;22944:68:0;;;22173:21:1;;;22210:18;;;22203:30;22269:34;22249:18;;;22242:62;22321:18;;22944:68:0;21989:356:1;48618:151:0;48722:39;48739:4;48745:2;48749:7;48722:39;;;;;;;;;;;;:16;:39::i;23983:191::-;24076:6;;;-1:-1:-1;;;;;24093:17:0;;;-1:-1:-1;;;;;;24093:17:0;;;;;;;24126:40;;24076:6;;;24093:17;24076:6;;24126:40;;24057:16;;24126:40;24046:128;23983:191;:::o;56739:281::-;56860:8;-1:-1:-1;;;;;56851:17:0;:5;-1:-1:-1;;;;;56851:17:0;;56843:55;;;;-1:-1:-1;;;56843:55:0;;22552:2:1;56843:55:0;;;22534:21:1;22591:2;22571:18;;;22564:30;22630:27;22610:18;;;22603:55;22675:18;;56843:55:0;22350:349:1;56843:55:0;-1:-1:-1;;;;;56909:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;56909:46:0;;;;;;;;;;56971:41;;725::1;;;56971::0;;698:18:1;56971:41:0;;;;;;;56739:281;;;:::o;51109:264::-;51202:4;51219:13;51235:23;51250:7;51235:14;:23::i;:::-;51219:39;;51288:5;-1:-1:-1;;;;;51277:16:0;:7;-1:-1:-1;;;;;51277:16:0;;:52;;;-1:-1:-1;;;;;;48136:25:0;;;48112:4;48136:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;51297:32;51277:87;;;;51357:7;-1:-1:-1;;;;;51333:31:0;:20;51345:7;51333:11;:20::i;:::-;-1:-1:-1;;;;;51333:31:0;;51277:87;51269:96;51109:264;-1:-1:-1;;;;51109:264:0:o;50000:270::-;50113:28;50123:4;50129:2;50133:7;50113:9;:28::i;:::-;50160:47;50183:4;50189:2;50193:7;50202:4;50160:22;:47::i;:::-;50152:110;;;;-1:-1:-1;;;50152:110:0;;;;;;;:::i;73084:108::-;73144:13;73177:7;73170:14;;;;;:::i;18193:716::-;18249:13;18300:14;18317:17;18328:5;18317:10;:17::i;:::-;18337:1;18317:21;18300:38;;18353:20;18387:6;18376:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18376:18:0;-1:-1:-1;18353:41:0;-1:-1:-1;18518:28:0;;;18534:2;18518:28;18575:288;-1:-1:-1;;18607:5:0;-1:-1:-1;;;18744:2:0;18733:14;;18728:30;18607:5;18715:44;18805:2;18796:11;;;-1:-1:-1;18826:21:0;18575:288;18826:21;-1:-1:-1;18884:6:0;18193:716;-1:-1:-1;;;18193:716:0:o;52052:285::-;52147:18;52153:2;52157:7;52147:5;:18::i;:::-;52198:53;52229:1;52233:2;52237:7;52246:4;52198:22;:53::i;:::-;52176:153;;;;-1:-1:-1;;;52176:153:0;;;;;;;:::i;55074:1229::-;55199:4;-1:-1:-1;;;;;55172:31:0;:23;55187:7;55172:14;:23::i;:::-;-1:-1:-1;;;;;55172:31:0;;55164:81;;;;-1:-1:-1;;;55164:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;55264:16:0;;55256:65;;;;-1:-1:-1;;;55256:65:0;;23863:2:1;55256:65:0;;;23845:21:1;23902:2;23882:18;;;23875:30;23941:34;23921:18;;;23914:62;-1:-1:-1;;;23992:18:1;;;23985:34;24036:19;;55256:65:0;23661:400:1;55256:65:0;55334:42;55355:4;55361:2;55365:7;55374:1;55334:20;:42::i;:::-;55506:4;-1:-1:-1;;;;;55479:31:0;:23;55494:7;55479:14;:23::i;:::-;-1:-1:-1;;;;;55479:31:0;;55471:81;;;;-1:-1:-1;;;55471:81:0;;;;;;;:::i;:::-;55624:24;;;;:15;:24;;;;;;;;55617:31;;-1:-1:-1;;;;;;55617:31:0;;;;;;-1:-1:-1;;;;;56100:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;56100:20:0;;;56135:13;;;;;;;;;:18;;55617:31;56135:18;;;56175:16;;;:7;:16;;;;;;:21;;;;;;;;;;56214:27;;55640:7;;56214:27;;;72575:121;72284:419;;:::o;57808:853::-;57962:4;-1:-1:-1;;;;;57983:13:0;;25950:19;:23;57979:675;;58019:71;;-1:-1:-1;;;58019:71:0;;-1:-1:-1;;;;;58019:36:0;;;;;:71;;21354:10;;58070:4;;58076:7;;58085:4;;58019:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;58019:71:0;;;;;;;;-1:-1:-1;;58019:71:0;;;;;;;;;;;;:::i;:::-;;;58015:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58260:6;:13;58277:1;58260:18;58256:328;;58303:60;;-1:-1:-1;;;58303:60:0;;;;;;;:::i;58256:328::-;58534:6;58528:13;58519:6;58515:2;58511:15;58504:38;58015:584;-1:-1:-1;;;;;;58141:51:0;-1:-1:-1;;;58141:51:0;;-1:-1:-1;58134:58:0;;57979:675;-1:-1:-1;58638:4:0;57808:853;;;;;;:::o;15027:948::-;15080:7;;-1:-1:-1;;;15158:17:0;;15154:106;;-1:-1:-1;;;15196:17:0;;;-1:-1:-1;15242:2:0;15232:12;15154:106;15287:8;15278:5;:17;15274:106;;15325:8;15316:17;;;-1:-1:-1;15362:2:0;15352:12;15274:106;15407:8;15398:5;:17;15394:106;;15445:8;15436:17;;;-1:-1:-1;15482:2:0;15472:12;15394:106;15527:7;15518:5;:16;15514:103;;15564:7;15555:16;;;-1:-1:-1;15600:1:0;15590:11;15514:103;15644:7;15635:5;:16;15631:103;;15681:7;15672:16;;;-1:-1:-1;15717:1:0;15707:11;15631:103;15761:7;15752:5;:16;15748:103;;15798:7;15789:16;;;-1:-1:-1;15834:1:0;15824:11;15748:103;15878:7;15869:5;:16;15865:68;;15916:1;15906:11;15961:6;15027:948;-1:-1:-1;;15027:948:0:o;52673:942::-;-1:-1:-1;;;;;52753:16:0;;52745:61;;;;-1:-1:-1;;;52745:61:0;;25016:2:1;52745:61:0;;;24998:21:1;;;25035:18;;;25028:30;25094:34;25074:18;;;25067:62;25146:18;;52745:61:0;24814:356:1;52745:61:0;50879:4;50477:16;;;:7;:16;;;;;;-1:-1:-1;;;;;50477:16:0;50903:31;52817:58;;;;-1:-1:-1;;;52817:58:0;;25377:2:1;52817:58:0;;;25359:21:1;25416:2;25396:18;;;25389:30;25455;25435:18;;;25428:58;25503:18;;52817:58:0;25175:352:1;52817:58:0;52888:48;52917:1;52921:2;52925:7;52934:1;52888:20;:48::i;:::-;50879:4;50477:16;;;:7;:16;;;;;;-1:-1:-1;;;;;50477:16:0;50903:31;53026:58;;;;-1:-1:-1;;;53026:58:0;;25377:2:1;53026:58:0;;;25359:21:1;25416:2;25396:18;;;25389:30;25455;25435:18;;;25428:58;25503:18;;53026:58:0;25175:352:1;53026:58:0;-1:-1:-1;;;;;53433:13:0;;;;;;:9;:13;;;;;;;;:18;;53450:1;53433:18;;;53475:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;53475:21:0;;;;;53514:33;53483:7;;53433:13;;53514:33;;53433:13;;53514:33;74374:107;74203:285;:::o;63122:915::-;63389:1;63377:9;:13;63373:222;;;63520:63;;-1:-1:-1;;;63520:63:0;;25734:2:1;63520:63:0;;;25716:21:1;25773:2;25753:18;;;25746:30;25812:34;25792:18;;;25785:62;-1:-1:-1;;;25863:18:1;;;25856:51;25924:19;;63520:63:0;25532:417:1;63373:222:0;63625:12;-1:-1:-1;;;;;63654:18:0;;63650:187;;63689:40;63721:7;64864:10;:17;;64837:24;;;;:15;:24;;;;;:44;;;64892:24;;;;;;;;;;;;64760:164;63689:40;63650:187;;;63759:2;-1:-1:-1;;;;;63751:10:0;:4;-1:-1:-1;;;;;63751:10:0;;63747:90;;63778:47;63811:4;63817:7;63778:32;:47::i;:::-;-1:-1:-1;;;;;63851:16:0;;63847:183;;63884:45;63921:7;63884:36;:45::i;:::-;63847:183;;;63957:4;-1:-1:-1;;;;;63951:10:0;:2;-1:-1:-1;;;;;63951:10:0;;63947:83;;63978:40;64006:2;64010:7;63978:27;:40::i;:::-;63288:749;63122:915;;;;:::o;65551:988::-;65817:22;65867:1;65842:22;65859:4;65842:16;:22::i;:::-;:26;;;;:::i;:::-;65879:18;65900:26;;;:17;:26;;;;;;65817:51;;-1:-1:-1;66033:28:0;;;66029:328;;-1:-1:-1;;;;;66100:18:0;;66078:19;66100:18;;;:12;:18;;;;;;;;:34;;;;;;;;;66151:30;;;;;;:44;;;66268:30;;:17;:30;;;;;:43;;;66029:328;-1:-1:-1;66453:26:0;;;;:17;:26;;;;;;;;66446:33;;;-1:-1:-1;;;;;66497:18:0;;;;;:12;:18;;;;;:34;;;;;;;66490:41;65551:988::o;66834:1079::-;67112:10;:17;67087:22;;67112:21;;67132:1;;67112:21;:::i;:::-;67144:18;67165:24;;;:15;:24;;;;;;67538:10;:26;;67087:46;;-1:-1:-1;67165:24:0;;67087:46;;67538:26;;;;;;:::i;:::-;;;;;;;;;67516:48;;67602:11;67577:10;67588;67577:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;67682:28;;;:15;:28;;;;;;;:41;;;67854:24;;;;;67847:31;67889:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;66905:1008;;;66834:1079;:::o;64338:221::-;64423:14;64440:20;64457:2;64440:16;:20::i;:::-;-1:-1:-1;;;;;64471:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;64516:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;64338:221:0:o;14:180:1:-;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;199:131::-;-1:-1:-1;;;;;;273:32:1;;263:43;;253:71;;320:1;317;310:12;335:245;393:6;446:2;434:9;425:7;421:23;417:32;414:52;;;462:1;459;452:12;414:52;501:9;488:23;520:30;544:5;520:30;:::i;777:173::-;845:20;;-1:-1:-1;;;;;894:31:1;;884:42;;874:70;;940:1;937;930:12;874:70;777:173;;;:::o;955:254::-;1023:6;1031;1084:2;1072:9;1063:7;1059:23;1055:32;1052:52;;;1100:1;1097;1090:12;1052:52;1123:29;1142:9;1123:29;:::i;:::-;1113:39;1199:2;1184:18;;;;1171:32;;-1:-1:-1;;;955:254:1:o;1396:250::-;1481:1;1491:113;1505:6;1502:1;1499:13;1491:113;;;1581:11;;;1575:18;1562:11;;;1555:39;1527:2;1520:10;1491:113;;;-1:-1:-1;;1638:1:1;1620:16;;1613:27;1396:250::o;1651:271::-;1693:3;1731:5;1725:12;1758:6;1753:3;1746:19;1774:76;1843:6;1836:4;1831:3;1827:14;1820:4;1813:5;1809:16;1774:76;:::i;:::-;1904:2;1883:15;-1:-1:-1;;1879:29:1;1870:39;;;;1911:4;1866:50;;1651:271;-1:-1:-1;;1651:271:1:o;1927:220::-;2076:2;2065:9;2058:21;2039:4;2096:45;2137:2;2126:9;2122:18;2114:6;2096:45;:::i;2360:186::-;2419:6;2472:2;2460:9;2451:7;2447:23;2443:32;2440:52;;;2488:1;2485;2478:12;2440:52;2511:29;2530:9;2511:29;:::i;2551:160::-;2616:20;;2672:13;;2665:21;2655:32;;2645:60;;2701:1;2698;2691:12;2716:180;2772:6;2825:2;2813:9;2804:7;2800:23;2796:32;2793:52;;;2841:1;2838;2831:12;2793:52;2864:26;2880:9;2864:26;:::i;2901:127::-;2962:10;2957:3;2953:20;2950:1;2943:31;2993:4;2990:1;2983:15;3017:4;3014:1;3007:15;3033:275;3104:2;3098:9;3169:2;3150:13;;-1:-1:-1;;3146:27:1;3134:40;;3204:18;3189:34;;3225:22;;;3186:62;3183:88;;;3251:18;;:::i;:::-;3287:2;3280:22;3033:275;;-1:-1:-1;3033:275:1:o;3313:952::-;3397:6;3428:2;3471;3459:9;3450:7;3446:23;3442:32;3439:52;;;3487:1;3484;3477:12;3439:52;3527:9;3514:23;3556:18;3597:2;3589:6;3586:14;3583:34;;;3613:1;3610;3603:12;3583:34;3651:6;3640:9;3636:22;3626:32;;3696:7;3689:4;3685:2;3681:13;3677:27;3667:55;;3718:1;3715;3708:12;3667:55;3754:2;3741:16;3776:2;3772;3769:10;3766:36;;;3782:18;;:::i;:::-;3828:2;3825:1;3821:10;3811:20;;3851:28;3875:2;3871;3867:11;3851:28;:::i;:::-;3913:15;;;3983:11;;;3979:20;;;3944:12;;;;4011:19;;;4008:39;;;4043:1;4040;4033:12;4008:39;4067:11;;;;4087:148;4103:6;4098:3;4095:15;4087:148;;;4169:23;4188:3;4169:23;:::i;:::-;4157:36;;4120:12;;;;4213;;;;4087:148;;;4254:5;3313:952;-1:-1:-1;;;;;;;;3313:952:1:o;4270:328::-;4347:6;4355;4363;4416:2;4404:9;4395:7;4391:23;4387:32;4384:52;;;4432:1;4429;4422:12;4384:52;4455:29;4474:9;4455:29;:::i;:::-;4445:39;;4503:38;4537:2;4526:9;4522:18;4503:38;:::i;:::-;4493:48;;4588:2;4577:9;4573:18;4560:32;4550:42;;4270:328;;;;;:::o;4603:407::-;4668:5;4702:18;4694:6;4691:30;4688:56;;;4724:18;;:::i;:::-;4762:57;4807:2;4786:15;;-1:-1:-1;;4782:29:1;4813:4;4778:40;4762:57;:::i;:::-;4753:66;;4842:6;4835:5;4828:21;4882:3;4873:6;4868:3;4864:16;4861:25;4858:45;;;4899:1;4896;4889:12;4858:45;4948:6;4943:3;4936:4;4929:5;4925:16;4912:43;5002:1;4995:4;4986:6;4979:5;4975:18;4971:29;4964:40;4603:407;;;;;:::o;5015:451::-;5084:6;5137:2;5125:9;5116:7;5112:23;5108:32;5105:52;;;5153:1;5150;5143:12;5105:52;5193:9;5180:23;5226:18;5218:6;5215:30;5212:50;;;5258:1;5255;5248:12;5212:50;5281:22;;5334:4;5326:13;;5322:27;-1:-1:-1;5312:55:1;;5363:1;5360;5353:12;5312:55;5386:74;5452:7;5447:2;5434:16;5429:2;5425;5421:11;5386:74;:::i;5471:254::-;5536:6;5544;5597:2;5585:9;5576:7;5572:23;5568:32;5565:52;;;5613:1;5610;5603:12;5565:52;5636:29;5655:9;5636:29;:::i;:::-;5626:39;;5684:35;5715:2;5704:9;5700:18;5684:35;:::i;:::-;5674:45;;5471:254;;;;;:::o;5730:667::-;5825:6;5833;5841;5849;5902:3;5890:9;5881:7;5877:23;5873:33;5870:53;;;5919:1;5916;5909:12;5870:53;5942:29;5961:9;5942:29;:::i;:::-;5932:39;;5990:38;6024:2;6013:9;6009:18;5990:38;:::i;:::-;5980:48;;6075:2;6064:9;6060:18;6047:32;6037:42;;6130:2;6119:9;6115:18;6102:32;6157:18;6149:6;6146:30;6143:50;;;6189:1;6186;6179:12;6143:50;6212:22;;6265:4;6257:13;;6253:27;-1:-1:-1;6243:55:1;;6294:1;6291;6284:12;6243:55;6317:74;6383:7;6378:2;6365:16;6360:2;6356;6352:11;6317:74;:::i;:::-;6307:84;;;5730:667;;;;;;;:::o;6402:632::-;6573:2;6625:21;;;6695:13;;6598:18;;;6717:22;;;6544:4;;6573:2;6796:15;;;;6770:2;6755:18;;;6544:4;6839:169;6853:6;6850:1;6847:13;6839:169;;;6914:13;;6902:26;;6983:15;;;;6948:12;;;;6875:1;6868:9;6839:169;;;-1:-1:-1;7025:3:1;;6402:632;-1:-1:-1;;;;;;6402:632:1:o;7039:260::-;7107:6;7115;7168:2;7156:9;7147:7;7143:23;7139:32;7136:52;;;7184:1;7181;7174:12;7136:52;7207:29;7226:9;7207:29;:::i;:::-;7197:39;;7255:38;7289:2;7278:9;7274:18;7255:38;:::i;7304:356::-;7506:2;7488:21;;;7525:18;;;7518:30;7584:34;7579:2;7564:18;;7557:62;7651:2;7636:18;;7304:356::o;8068:341::-;8270:2;8252:21;;;8309:2;8289:18;;;8282:30;-1:-1:-1;;;8343:2:1;8328:18;;8321:47;8400:2;8385:18;;8068:341::o;8414:127::-;8475:10;8470:3;8466:20;8463:1;8456:31;8506:4;8503:1;8496:15;8530:4;8527:1;8520:15;8546:125;8611:9;;;8632:10;;;8629:36;;;8645:18;;:::i;9023:135::-;9062:3;9083:17;;;9080:43;;9103:18;;:::i;:::-;-1:-1:-1;9150:1:1;9139:13;;9023:135::o;9163:380::-;9242:1;9238:12;;;;9285;;;9306:61;;9360:4;9352:6;9348:17;9338:27;;9306:61;9413:2;9405:6;9402:14;9382:18;9379:38;9376:161;;9459:10;9454:3;9450:20;9447:1;9440:31;9494:4;9491:1;9484:15;9522:4;9519:1;9512:15;9376:161;;9163:380;;;:::o;10380:127::-;10441:10;10436:3;10432:20;10429:1;10422:31;10472:4;10469:1;10462:15;10496:4;10493:1;10486:15;12634:168;12707:9;;;12738;;12755:15;;;12749:22;;12735:37;12725:71;;12776:18;;:::i;15674:518::-;15776:2;15771:3;15768:11;15765:421;;;15812:5;15809:1;15802:16;15856:4;15853:1;15843:18;15926:2;15914:10;15910:19;15907:1;15903:27;15897:4;15893:38;15962:4;15950:10;15947:20;15944:47;;;-1:-1:-1;15985:4:1;15944:47;16040:2;16035:3;16031:12;16028:1;16024:20;16018:4;16014:31;16004:41;;16095:81;16113:2;16106:5;16103:13;16095:81;;;16172:1;16158:16;;16139:1;16128:13;16095:81;;16368:1345;16494:3;16488:10;16521:18;16513:6;16510:30;16507:56;;;16543:18;;:::i;:::-;16572:97;16662:6;16622:38;16654:4;16648:11;16622:38;:::i;:::-;16616:4;16572:97;:::i;:::-;16724:4;;16781:2;16770:14;;16798:1;16793:663;;;;17500:1;17517:6;17514:89;;;-1:-1:-1;17569:19:1;;;17563:26;17514:89;-1:-1:-1;;16325:1:1;16321:11;;;16317:24;16313:29;16303:40;16349:1;16345:11;;;16300:57;17616:81;;16763:944;;16793:663;15621:1;15614:14;;;15658:4;15645:18;;-1:-1:-1;;16829:20:1;;;16947:236;16961:7;16958:1;16955:14;16947:236;;;17050:19;;;17044:26;17029:42;;17142:27;;;;17110:1;17098:14;;;;16977:19;;16947:236;;;16951:3;17211:6;17202:7;17199:19;17196:201;;;17272:19;;;17266:26;-1:-1:-1;;17355:1:1;17351:14;;;17367:3;17347:24;17343:37;17339:42;17324:58;17309:74;;17196:201;;;17443:1;17434:6;17431:1;17427:14;17423:22;17417:4;17410:36;16763:944;;;;;16368:1345;;:::o;20307:409::-;20509:2;20491:21;;;20548:2;20528:18;;;20521:30;20587:34;20582:2;20567:18;;20560:62;-1:-1:-1;;;20653:2:1;20638:18;;20631:43;20706:3;20691:19;;20307:409::o;20721:496::-;20900:3;20938:6;20932:13;20954:66;21013:6;21008:3;21001:4;20993:6;20989:17;20954:66;:::i;:::-;21083:13;;21042:16;;;;21105:70;21083:13;21042:16;21152:4;21140:17;;21105:70;:::i;:::-;21191:20;;20721:496;-1:-1:-1;;;;20721:496:1:o;22704:414::-;22906:2;22888:21;;;22945:2;22925:18;;;22918:30;22984:34;22979:2;22964:18;;22957:62;-1:-1:-1;;;23050:2:1;23035:18;;23028:48;23108:3;23093:19;;22704:414::o;23255:401::-;23457:2;23439:21;;;23496:2;23476:18;;;23469:30;23535:34;23530:2;23515:18;;23508:62;-1:-1:-1;;;23601:2:1;23586:18;;23579:35;23646:3;23631:19;;23255:401::o;24066:489::-;-1:-1:-1;;;;;24335:15:1;;;24317:34;;24387:15;;24382:2;24367:18;;24360:43;24434:2;24419:18;;24412:34;;;24482:3;24477:2;24462:18;;24455:31;;;24260:4;;24503:46;;24529:19;;24521:6;24503:46;:::i;:::-;24495:54;24066:489;-1:-1:-1;;;;;;24066:489:1:o;24560:249::-;24629:6;24682:2;24670:9;24661:7;24657:23;24653:32;24650:52;;;24698:1;24695;24688:12;24650:52;24730:9;24724:16;24749:30;24773:5;24749:30;:::i;25954:128::-;26021:9;;;26042:11;;;26039:37;;;26056:18;;:::i;26087:127::-;26148:10;26143:3;26139:20;26136:1;26129:31;26179:4;26176:1;26169:15;26203:4;26200:1;26193:15

Swarm Source

ipfs://9a4f28479edf6c766594a040b569fcb3759c4d47a3608ecf79b448805b01ea7a

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services