Token

Mutant Women Ape Yacht Club (MWAYC)

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

ERC-721

Overview

Max Total Supply

1,106 MWAYC

Holders

216

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xe814d400743fdcaef3be2a22ec5bf53f2ed3c885

Filtered by Token Holder

0xcC7af7Cd4d46804163aE90A7345F9536364F16d2

Balance

2 MWAYC

0xcc7af7cd4d46804163ae90a7345f9536364f16d2

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

MutantWomenApeYachtClub

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-01-17
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/Counters.sol


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

// File: IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;

interface IOperatorFilterRegistry {
    function isOperatorAllowed(address registrant, address operator) external view returns (bool);
    function register(address registrant) external;
    function registerAndSubscribe(address registrant, address subscription) external;
    function registerAndCopyEntries(address registrant, address registrantToCopy) external;
    function unregister(address addr) external;
    function updateOperator(address registrant, address operator, bool filtered) external;
    function updateOperators(address registrant, address[] calldata operators, bool filtered) external;
    function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external;
    function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external;
    function subscribe(address registrant, address registrantToSubscribe) external;
    function unsubscribe(address registrant, bool copyExistingEntries) external;
    function subscriptionOf(address addr) external returns (address registrant);
    function subscribers(address registrant) external returns (address[] memory);
    function subscriberAt(address registrant, uint256 index) external returns (address);
    function copyEntriesOf(address registrant, address registrantToCopy) external;
    function isOperatorFiltered(address registrant, address operator) external returns (bool);
    function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool);
    function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool);
    function filteredOperators(address addr) external returns (address[] memory);
    function filteredCodeHashes(address addr) external returns (bytes32[] memory);
    function filteredOperatorAt(address registrant, uint256 index) external returns (address);
    function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32);
    function isRegistered(address addr) external returns (bool);
    function codeHashOf(address addr) external returns (bytes32);
}

// File: OperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 */
abstract contract OperatorFilterer {
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(0x000000000000AAeB6D7670E522A718067333cd4E);

    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy);
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy);
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

// File: DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 */
abstract contract DefaultOperatorFilterer is OperatorFilterer {
    address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6);

    constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {}
}

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


// OpenZeppelin Contracts (last updated v4.8.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) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 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 10, 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 * 8) < value ? 1 : 0);
        }
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.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 `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);
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.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
     * ====
     *
     * [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://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

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

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


// OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be paid in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

// 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/common/ERC2981.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol)

pragma solidity ^0.8.0;



/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

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


// OpenZeppelin Contracts (last updated v4.8.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/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/security/Pausable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;


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

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

    bool private _paused;

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v4.8.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 {
        if (batchSize > 1) {
            if (from != address(0)) {
                _balances[from] -= batchSize;
            }
            if (to != address(0)) {
                _balances[to] += batchSize;
            }
        }
    }

    /**
     * @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 {}
}

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


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

pragma solidity ^0.8.0;




/**
 * @dev Extension of ERC721 with the ERC2981 NFT Royalty Standard, a standardized way to retrieve royalty payment
 * information.
 *
 * Royalty information can be specified globally for all token ids via {ERC2981-_setDefaultRoyalty}, and/or individually for
 * specific token ids via {ERC2981-_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC721Royalty is ERC2981, ERC721 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC2981) returns (bool) {
        return super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {ERC721-_burn}. This override additionally clears the royalty information for the token.
     */
    function _burn(uint256 tokenId) internal virtual override {
        super._burn(tokenId);
        _resetTokenRoyalty(tokenId);
    }
}

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


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

pragma solidity ^0.8.0;



/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved");
        _burn(tokenId);
    }
}

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


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/extensions/ERC721URIStorage.sol)

pragma solidity ^0.8.0;


/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

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

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev See {ERC721-_burn}. This override additionally checks to see if a
     * token-specific URI was set for the token, and if so, it deletes the token URI from
     * the storage mapping.
     */
    function _burn(uint256 tokenId) internal virtual override {
        super._burn(tokenId);

        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}

// 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: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.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 anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _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: contracts/mutant.sol



pragma solidity >=0.7.0 <0.9.0;












contract MutantWomenApeYachtClub is DefaultOperatorFilterer, ERC721, ERC721Enumerable, ERC721URIStorage, Pausable, Ownable, ERC721Burnable, ERC721Royalty {
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;

    uint256 public cost = 0.08 ether;
    uint256 public mintSupply = 2222;
    uint256 public xclubSupply = 3333;
    uint256 public waycSupply = 10000;
    uint256 public xclubTotalSupply = 0;
    uint256 public waycTotalSupply = 0;
    uint256 public mwaycTotalSupply = 0;
    uint256 public maxMintAmountPerTx = 50;

    string public BaseURI = "ipfs://";

    address public owner_address = msg.sender;
    address public xclub;
    address public wayc;

    mapping (uint256 => string) private _tokenURIs;
    
    mapping(uint256 => bool) public xclubTokenStatus;
    mapping(uint256 => bool) public waycTokenStatus;

    constructor() ERC721("Mutant Women Ape Yacht Club", "MWAYC") {
        _setDefaultRoyalty(owner_address, 500);
    }

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

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

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

    function setRoyalty(address _address, uint96 _royalty) public onlyOwner {
        _setDefaultRoyalty(_address, _royalty*100);
    }

    function setBaseURI(string memory _URI) public onlyOwner {
        BaseURI = _URI;
    }

    function xclubClaim(uint256[] memory _tokensId) public {
        require(xclubTotalSupply + _tokensId.length <= xclubSupply, "Not enough left to mint all your requests");

        for(uint256 i; i < _tokensId.length; i++) {
            if (IERC721(xclub).ownerOf(_tokensId[i]) == msg.sender && !xclubTokenStatus[_tokensId[i]]) {
                safeMint(msg.sender);
                xclubTotalSupply++;
                xclubTokenStatus[_tokensId[i]] = true;
            }
        }
    }

    function waycClaim(uint256[] memory _tokensId) public {
        require(waycTotalSupply + _tokensId.length <= waycSupply, "Not enough left to mint all your requests");

        for(uint256 i; i < _tokensId.length; i++) {
            if (IERC721(wayc).ownerOf(_tokensId[i]) == msg.sender && !waycTokenStatus[_tokensId[i]]) {
                safeMint(msg.sender);
                waycTotalSupply++;
                waycTokenStatus[_tokensId[i]] = true;
            }
        }
    }

    function mint(uint256 _mintAmount) public payable {
        require(_mintAmount > 0 && _mintAmount <= maxMintAmountPerTx, "Invalid mint amount");
        require(msg.value >= _mintAmount * cost, "Not enough ether sent");
        require(mwaycTotalSupply + _mintAmount <= mintSupply, "Not enough left to mint all your requests");
        for (uint256 i = 0; i < _mintAmount; i++) {
            safeMint(msg.sender);
            mwaycTotalSupply++;
        }
    }

    function airdrop(address[] memory _adresses, uint256 _mintAmount) public onlyOwner {
        for (uint256 j = 0; j < _adresses.length; j++) {
            for (uint256 i = 0; i < _mintAmount; i++) {
                safeMint(_adresses[j]);
                mwaycTotalSupply++;
            }
        }
    }

    function safeMint(address to) internal {
        uint256 tokenId = _tokenIdCounter.current() + 1;
        _tokenIdCounter.increment();
        _safeMint(to, tokenId);
        _setTokenURI(tokenId);
    }

    function waycTokenIds(address _address) public view returns(uint256[] memory) {
        uint256 ownerTokenCount = IERC721(wayc).balanceOf(_address);
        uint256[] memory ownedTokenIds = new uint256[](ownerTokenCount);
        uint256 currentTokenId = 0;
        uint256 ownedTokenIndex = 0;
        uint256 _i = 0;
        while (ownedTokenIndex < ownerTokenCount && currentTokenId <= waycSupply) {
            address currentTokenOwner = IERC721(wayc).ownerOf(currentTokenId);
            if (currentTokenOwner == _address) {
                if(!waycTokenStatus[currentTokenId]) {
                    ownedTokenIds[_i] = currentTokenId;
                    _i++;
                }
                ownedTokenIndex++;
            }
            currentTokenId++;
        }
        return ownedTokenIds;
    }

    function waycBalanceOf(uint256 _tokenId) public view returns(address) {
        return IERC721(wayc).ownerOf(_tokenId);
    }

    function xclubRealTotalSupply() public view returns(uint256) {
        return IERC721Enumerable(xclub).totalSupply();
    }

    function xclubTokenIds(address _address) public view returns(uint256[] memory) {
        uint256 ownerTokenCount = IERC721(xclub).balanceOf(_address);
        uint256[] memory tokenIds = new uint256[](ownerTokenCount);
        uint256 _j = 0;
        for (uint256 i; i < ownerTokenCount; i++) {
            uint256 _tokenId = IERC721Enumerable(xclub).tokenOfOwnerByIndex(_address, i);
            if(!xclubTokenStatus[_tokenId]) {
                tokenIds[_j] = _tokenId;
                _j++;
            }
        }
        return tokenIds;
    }

    function setmaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
        maxMintAmountPerTx = _maxMintAmountPerTx;
    }

    function setMintSupply(uint256 _mintSupply) external onlyOwner {
        mintSupply = _mintSupply;
    }

    function setXclubSupply(uint256 _xclubSupply) external onlyOwner {
        xclubSupply = _xclubSupply;
    }

    function setWaycSupply(uint256 _waycSupply) external onlyOwner {
        waycSupply = _waycSupply;
    }

    function setcost(uint256 _cost) external onlyOwner {
        cost = _cost;
    }

    function setXclub(address _xclub) external onlyOwner {
        xclub = _xclub;
    }

    function setWayc(address _wayc) external onlyOwner {
        wayc = _wayc;
    }

    function withdraw() public onlyOwner {
        (bool os, ) = payable(owner()).call{value: address(this).balance}("");
        require(os);
    }

    function _beforeTokenTransfer(address from, address to, uint256 tokenId, uint256 batchSize)
        internal
        whenNotPaused
        override(ERC721, ERC721Enumerable)
    {
        super._beforeTokenTransfer(from, to, tokenId, batchSize);
    }

    // The following functions are overrides required by Solidity.
    function _burn(uint256 tokenId) internal override(ERC721, ERC721URIStorage, ERC721Royalty) {
        super._burn(tokenId);
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721, ERC721URIStorage)
        returns (string memory)
    {
        return string.concat(super.tokenURI(tokenId), ".json");
    }

    function _setTokenURI(uint256 tokenId) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        string memory suffix = string.concat(Strings.toString(tokenId), ".json");
        string memory _tokenURI = string(abi.encodePacked(_baseURI(), suffix));
        _tokenURIs[tokenId] = _tokenURI;
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721, ERC721Enumerable, ERC721Royalty)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

     function setApprovalForAll(address operator, bool approved) 
        public 
        override(ERC721,IERC721)
        onlyAllowedOperatorApproval(operator) 
    {
        super.setApprovalForAll(operator, approved);
    }

    function approve(address operator, uint256 tokenId) 
        public 
        override(ERC721,IERC721)
        onlyAllowedOperatorApproval(operator) 
    {
        super.approve(operator, tokenId);
    }

    function transferFrom(address from, address to, uint256 tokenId) 
        public 
        override(ERC721,IERC721)
        onlyAllowedOperator(from) 
    {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId) 
        public 
        override(ERC721,IERC721)
        onlyAllowedOperator(from) 
    {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
        public
        override(ERC721,IERC721)
        onlyAllowedOperator(from)
    {
        super.safeTransferFrom(from, to, tokenId, data);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"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":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"BaseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_adresses","type":"address[]"},{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","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":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":[],"name":"maxMintAmountPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mwaycTotalSupply","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":"owner_address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"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":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_URI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintSupply","type":"uint256"}],"name":"setMintSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"},{"internalType":"uint96","name":"_royalty","type":"uint96"}],"name":"setRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_wayc","type":"address"}],"name":"setWayc","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_waycSupply","type":"uint256"}],"name":"setWaycSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_xclub","type":"address"}],"name":"setXclub","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_xclubSupply","type":"uint256"}],"name":"setXclubSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cost","type":"uint256"}],"name":"setcost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxMintAmountPerTx","type":"uint256"}],"name":"setmaxMintAmountPerTx","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":"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":[],"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":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"wayc","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"waycBalanceOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokensId","type":"uint256[]"}],"name":"waycClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"waycSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"waycTokenIds","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"waycTokenStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"waycTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"xclub","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokensId","type":"uint256[]"}],"name":"xclubClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"xclubRealTotalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xclubSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"xclubTokenIds","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"xclubTokenStatus","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"xclubTotalSupply","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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

Deployed Bytecode Sourcemap

81333:8567:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88514:227;;;;;;;;;;-1:-1:-1;88514:227:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;88514:227:0;;;;;;;;81626:32;;;;;;;;;;;;;;;;;;;738:25:1;;;726:2;711:18;81626:32:0;592:177:1;52394:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;53906:171::-;;;;;;;;;;-1:-1:-1;53906:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1879:32:1;;;1861:51;;1849:2;1834:18;53906:171:0;1715:203:1;88985:208:0;;;;;;;;;;-1:-1:-1;88985:208:0;;;;;:::i;:::-;;:::i;:::-;;85833:125;;;;;;;;;;;;;:::i;86910:106::-;;;;;;;;;;-1:-1:-1;86910:106:0;;;;;:::i;:::-;;:::i;81587:32::-;;;;;;;;;;;;;;;;73244:113;;;;;;;;;;-1:-1:-1;73332:10:0;:17;73244:113;;89201:214;;;;;;;;;;-1:-1:-1;89201:214:0;;;;;:::i;:::-;;:::i;81745:35::-;;;;;;;;;;;;;;;;87024:82;;;;;;;;;;-1:-1:-1;87024:82:0;;;;;:::i;:::-;;:::i;37017:442::-;;;;;;;;;;-1:-1:-1;37017:442:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3285:32:1;;;3267:51;;3349:2;3334:18;;3327:34;;;;3240:18;37017:442:0;3093:274:1;82034:19:0;;;;;;;;;;-1:-1:-1;82034:19:0;;;;-1:-1:-1;;;;;82034:19:0;;;72912:256;;;;;;;;;;-1:-1:-1;72912:256:0;;;;;:::i;:::-;;:::i;82847:497::-;;;;;;;;;;-1:-1:-1;82847:497:0;;;;;:::i;:::-;;:::i;87114:86::-;;;;;;;;;;-1:-1:-1;87114:86:0;;;;;:::i;:::-;;:::i;87298:147::-;;;;;;;;;;;;;:::i;82535:65::-;;;;;;;;;;;;;:::i;4367:143::-;;;;;;;;;;;;4467:42;4367:143;;89423:222;;;;;;;;;;-1:-1:-1;89423:222:0;;;;;:::i;:::-;;:::i;69368:242::-;;;;;;;;;;-1:-1:-1;69368:242:0;;;;;:::i;:::-;;:::i;84862:828::-;;;;;;;;;;-1:-1:-1;84862:828:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;73434:233::-;;;;;;;;;;-1:-1:-1;73434:233:0;;;;;:::i;:::-;;:::i;83352:490::-;;;;;;;;;;-1:-1:-1;83352:490:0;;;;;:::i;:::-;;:::i;86534:136::-;;;;;;;;;;-1:-1:-1;86534:136:0;;;;;:::i;:::-;;:::i;82749:90::-;;;;;;;;;;-1:-1:-1;82749:90:0;;;;;:::i;:::-;;:::i;49077:86::-;;;;;;;;;;-1:-1:-1;49148:7:0;;;;49077:86;;85698:127;;;;;;;;;;-1:-1:-1;85698:127:0;;;;;:::i;:::-;;:::i;52104:223::-;;;;;;;;;;-1:-1:-1;52104:223:0;;;;;:::i;:::-;;:::i;81828:35::-;;;;;;;;;;;;;;;;82121:48;;;;;;;;;;-1:-1:-1;82121:48:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;86792:110;;;;;;;;;;-1:-1:-1;86792:110:0;;;;;:::i;:::-;;:::i;51835:207::-;;;;;;;;;;-1:-1:-1;51835:207:0;;;;;:::i;:::-;;:::i;80422:103::-;;;;;;;;;;;;;:::i;81787:34::-;;;;;;;;;;;;;;;;81959:41;;;;;;;;;;-1:-1:-1;81959:41:0;;;;-1:-1:-1;;;;;81959:41:0;;;82466:61;;;;;;;;;;;;;:::i;79774:87::-;;;;;;;;;;-1:-1:-1;79847:6:0;;;;;-1:-1:-1;;;;;79847:6:0;79774:87;;82608:133;;;;;;;;;;-1:-1:-1;82608:133:0;;;;;:::i;:::-;;:::i;81870:38::-;;;;;;;;;;;;;;;;52563:104;;;;;;;;;;;;;:::i;83850:470::-;;;;;;:::i;:::-;;:::i;88750:227::-;;;;;;;;;;-1:-1:-1;88750:227:0;;;;;:::i;:::-;;:::i;82176:47::-;;;;;;;;;;-1:-1:-1;82176:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;86678:106;;;;;;;;;;-1:-1:-1;86678:106:0;;;;;:::i;:::-;;:::i;81705:33::-;;;;;;;;;;;;;;;;89653:244;;;;;;;;;;-1:-1:-1;89653:244:0;;;;;:::i;:::-;;:::i;81665:33::-;;;;;;;;;;;;;;;;84328:310;;;;;;;;;;-1:-1:-1;84328:310:0;;;;;:::i;:::-;;:::i;87924:220::-;;;;;;;;;;-1:-1:-1;87924:220:0;;;;;:::i;:::-;;:::i;87208:82::-;;;;;;;;;;-1:-1:-1;87208:82:0;;;;;:::i;:::-;;:::i;82007:20::-;;;;;;;;;;-1:-1:-1;82007:20:0;;;;-1:-1:-1;;;;;82007:20:0;;;85966:560;;;;;;;;;;-1:-1:-1;85966:560:0;;;;;:::i;:::-;;:::i;54375:164::-;;;;;;;;;;-1:-1:-1;54375:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;54496:25:0;;;54472:4;54496:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;54375:164;80680:201;;;;;;;;;;-1:-1:-1;80680:201:0;;;;;:::i;:::-;;:::i;81917:33::-;;;;;;;;;;;;;:::i;88514:227::-;88668:4;88697:36;88721:11;88697:23;:36::i;:::-;88690:43;88514:227;-1:-1:-1;;88514:227:0:o;52394:100::-;52448:13;52481:5;52474:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52394:100;:::o;53906:171::-;53982:7;54002:23;54017:7;54002:14;:23::i;:::-;-1:-1:-1;54045:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;54045:24:0;;53906:171::o;88985:208::-;89126:8;5888:30;5909:8;5888:20;:30::i;:::-;89153:32:::1;89167:8;89177:7;89153:13;:32::i;:::-;88985:208:::0;;;:::o;85833:125::-;85930:5;;85912:38;;;-1:-1:-1;;;85912:38:0;;;;85885:7;;-1:-1:-1;;;;;85930:5:0;;85912:36;;:38;;;;;;;;;;;;;;85930:5;85912:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;85905:45;;85833:125;:::o;86910:106::-;79660:13;:11;:13::i;:::-;86984:10:::1;:24:::0;86910:106::o;89201:214::-;89347:4;-1:-1:-1;;;;;5708:18:0;;5716:10;5708:18;5704:83;;5743:32;5764:10;5743:20;:32::i;:::-;89370:37:::1;89389:4;89395:2;89399:7;89370:18;:37::i;:::-;89201:214:::0;;;;:::o;87024:82::-;79660:13;:11;:13::i;:::-;87086:4:::1;:12:::0;87024:82::o;37017:442::-;37114:7;37172:27;;;:17;:27;;;;;;;;37143:56;;;;;;;;;-1:-1:-1;;;;;37143:56:0;;;;;-1:-1:-1;;;37143:56:0;;;-1:-1:-1;;;;;37143:56:0;;;;;;;;37114:7;;37212:92;;-1:-1:-1;37263:29:0;;;;;;;;;-1:-1:-1;37263:29:0;-1:-1:-1;;;;;37263:29:0;;;;-1:-1:-1;;;37263:29:0;;-1:-1:-1;;;;;37263:29:0;;;;;37212:92;37354:23;;;;37316:21;;37825:5;;37341:36;;-1:-1:-1;;;;;37341:36:0;:10;:36;:::i;:::-;37340:58;;;;:::i;:::-;37419:16;;;;;-1:-1:-1;37017:442:0;;-1:-1:-1;;;;37017:442:0:o;72912:256::-;73009:7;73045:23;73062:5;73045:16;:23::i;:::-;73037:5;:31;73029:87;;;;-1:-1:-1;;;73029:87:0;;11483:2:1;73029:87:0;;;11465:21:1;11522:2;11502:18;;;11495:30;11561:34;11541:18;;;11534:62;-1:-1:-1;;;11612:18:1;;;11605:41;11663:19;;73029:87:0;;;;;;;;;-1:-1:-1;;;;;;73134:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;72912:256::o;82847:497::-;82960:11;;82940:9;:16;82921;;:35;;;;:::i;:::-;:50;;82913:104;;;;-1:-1:-1;;;82913:104:0;;;;;;;:::i;:::-;83034:9;83030:307;83049:9;:16;83045:1;:20;83030:307;;;83099:5;;83114:12;;83131:10;;-1:-1:-1;;;;;83099:5:0;;83091:22;;83114:9;;83124:1;;83114:12;;;;;;:::i;:::-;;;;;;;83091:36;;;;;;;;;;;;;738:25:1;;726:2;711:18;;592:177;83091:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;83091:50:0;;:85;;;;;83146:16;:30;83163:9;83173:1;83163:12;;;;;;;;:::i;:::-;;;;;;;;;;;;83146:30;;;;;;;;;;-1:-1:-1;83146:30:0;;;;83145:31;83091:85;83087:239;;;83197:20;83206:10;83197:8;:20::i;:::-;83236:16;:18;;;:16;:18;;;:::i;:::-;;;;;;83306:4;83273:16;:30;83290:9;83300:1;83290:12;;;;;;;;:::i;:::-;;;;;;;83273:30;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;83087:239;83067:3;;;;:::i;:::-;;;;83030:307;;;;82847:497;:::o;87114:86::-;79660:13;:11;:13::i;:::-;87178:5:::1;:14:::0;;-1:-1:-1;;;;;;87178:14:0::1;-1:-1:-1::0;;;;;87178:14:0;;;::::1;::::0;;;::::1;::::0;;87114:86::o;87298:147::-;79660:13;:11;:13::i;:::-;79847:6;;87360:55:::1;::::0;87347:7:::1;::::0;79847:6;;;-1:-1:-1;;;;;79847:6:0;;87389:21:::1;::::0;87347:7;87360:55;87347:7;87360:55;87389:21;79847:6;87360:55:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;87346:69;;;87434:2;87426:11;;;::::0;::::1;;87335:110;87298:147::o:0;82535:65::-;79660:13;:11;:13::i;:::-;82582:10:::1;:8;:10::i;:::-;82535:65::o:0;89423:222::-;89573:4;-1:-1:-1;;;;;5708:18:0;;5716:10;5708:18;5704:83;;5743:32;5764:10;5743:20;:32::i;:::-;89596:41:::1;89619:4;89625:2;89629:7;89596:22;:41::i;69368:242::-:0;69486:41;47270:10;69505:12;69519:7;69486:18;:41::i;:::-;69478:99;;;;-1:-1:-1;;;69478:99:0;;;;;;;:::i;:::-;69588:14;69594:7;69588:5;:14::i;84862:828::-;84985:4;;84977:33;;-1:-1:-1;;;84977:33:0;;-1:-1:-1;;;;;1879:32:1;;;84977:33:0;;;1861:51:1;84922:16:0;;84951:23;;84985:4;;;84977:23;;1834:18:1;;84977:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;84951:59;;85021:30;85068:15;85054:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;85054:30:0;;85021:63;;85095:22;85132:23;85170:10;85195:457;85220:15;85202;:33;:65;;;;;85257:10;;85239:14;:28;;85202:65;85195:457;;;85320:4;;85312:37;;-1:-1:-1;;;85312:37:0;;;;;738:25:1;;;85284::0;;-1:-1:-1;;;;;85320:4:0;;85312:21;;711:18:1;;85312:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;85284:65;;85389:8;-1:-1:-1;;;;;85368:29:0;:17;-1:-1:-1;;;;;85368:29:0;;85364:246;;85422:31;;;;:15;:31;;;;;;;;85418:141;;85498:14;85478:13;85492:2;85478:17;;;;;;;;:::i;:::-;;;;;;;;;;:34;85535:4;;;;:::i;:::-;;;;85418:141;85577:17;;;;:::i;:::-;;;;85364:246;85624:16;;;;:::i;:::-;;;;85269:383;85195:457;;;-1:-1:-1;85669:13:0;;84862:828;-1:-1:-1;;;;;84862:828:0:o;73434:233::-;73509:7;73545:30;73332:10;:17;;73244:113;73545:30;73537:5;:38;73529:95;;;;-1:-1:-1;;;73529:95:0;;13587:2:1;73529:95:0;;;13569:21:1;13626:2;13606:18;;;13599:30;13665:34;13645:18;;;13638:62;-1:-1:-1;;;13716:18:1;;;13709:42;13768:19;;73529:95:0;13385:408:1;73529:95:0;73642:10;73653:5;73642:17;;;;;;;;:::i;:::-;;;;;;;;;73635:24;;73434:233;;;:::o;83352:490::-;83463:10;;83443:9;:16;83425:15;;:34;;;;:::i;:::-;:48;;83417:102;;;;-1:-1:-1;;;83417:102:0;;;;;;;:::i;:::-;83536:9;83532:303;83551:9;:16;83547:1;:20;83532:303;;;83601:4;;83615:12;;83632:10;;-1:-1:-1;;;;;83601:4:0;;83593:21;;83615:9;;83625:1;;83615:12;;;;;;:::i;:::-;;;;;;;83593:35;;;;;;;;;;;;;738:25:1;;726:2;711:18;;592:177;83593:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;83593:49:0;;:83;;;;;83647:15;:29;83663:9;83673:1;83663:12;;;;;;;;:::i;:::-;;;;;;;;;;;;83647:29;;;;;;;;;;-1:-1:-1;83647:29:0;;;;83646:30;83593:83;83589:235;;;83697:20;83706:10;83697:8;:20::i;:::-;83736:15;:17;;;:15;:17;;;:::i;:::-;;;;;;83804:4;83772:15;:29;83788:9;83798:1;83788:12;;;;;;;;:::i;:::-;;;;;;;83772:29;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;83589:235;83569:3;;;;:::i;:::-;;;;83532:303;;86534:136;79660:13;:11;:13::i;:::-;86622:18:::1;:40:::0;86534:136::o;82749:90::-;79660:13;:11;:13::i;:::-;82817:7:::1;:14;82827:4:::0;82817:7;:14:::1;:::i;85698:127::-:0;85794:4;;85786:31;;-1:-1:-1;;;85786:31:0;;;;;738:25:1;;;85759:7:0;;-1:-1:-1;;;;;85794:4:0;;85786:21;;711:18:1;;85786:31:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;52104:223::-;52176:7;56991:16;;;:7;:16;;;;;;-1:-1:-1;;;;;56991:16:0;;52240:56;;;;-1:-1:-1;;;52240:56:0;;16204:2:1;52240:56:0;;;16186:21:1;16243:2;16223:18;;;16216:30;-1:-1:-1;;;16262:18:1;;;16255:54;16326:18;;52240:56:0;16002:348:1;86792:110:0;79660:13;:11;:13::i;:::-;86868:11:::1;:26:::0;86792:110::o;51835:207::-;51907:7;-1:-1:-1;;;;;51935:19:0;;51927:73;;;;-1:-1:-1;;;51927:73:0;;16557:2:1;51927:73:0;;;16539:21:1;16596:2;16576:18;;;16569:30;16635:34;16615:18;;;16608:62;-1:-1:-1;;;16686:18:1;;;16679:39;16735:19;;51927:73:0;16355:405:1;51927:73:0;-1:-1:-1;;;;;;52018:16:0;;;;;:9;:16;;;;;;;51835:207::o;80422:103::-;79660:13;:11;:13::i;:::-;80487:30:::1;80514:1;80487:18;:30::i;82466:61::-:0;79660:13;:11;:13::i;:::-;82511:8:::1;:6;:8::i;82608:133::-:0;79660:13;:11;:13::i;:::-;82691:42:::1;82710:8:::0;82720:12:::1;:8:::0;82729:3:::1;82720:12;:::i;:::-;82691:18;:42::i;52563:104::-:0;52619:13;52652:7;52645:14;;;;;:::i;83850:470::-;83933:1;83919:11;:15;:52;;;;;83953:18;;83938:11;:33;;83919:52;83911:84;;;;-1:-1:-1;;;83911:84:0;;17237:2:1;83911:84:0;;;17219:21:1;17276:2;17256:18;;;17249:30;-1:-1:-1;;;17295:18:1;;;17288:49;17354:18;;83911:84:0;17035:343:1;83911:84:0;84041:4;;84027:18;;:11;:18;:::i;:::-;84014:9;:31;;84006:65;;;;-1:-1:-1;;;84006:65:0;;17585:2:1;84006:65:0;;;17567:21:1;17624:2;17604:18;;;17597:30;-1:-1:-1;;;17643:18:1;;;17636:51;17704:18;;84006:65:0;17383:345:1;84006:65:0;84124:10;;84109:11;84090:16;;:30;;;;:::i;:::-;:44;;84082:98;;;;-1:-1:-1;;;84082:98:0;;;;;;;:::i;:::-;84196:9;84191:122;84215:11;84211:1;:15;84191:122;;;84248:20;84257:10;84248:8;:20::i;:::-;84283:16;:18;;;:16;:18;;;:::i;:::-;;;;;;84228:3;;;;;:::i;:::-;;;;84191:122;;88750:227;88899:8;5888:30;5909:8;5888:20;:30::i;:::-;88926:43:::1;88950:8;88960;88926:23;:43::i;86678:106::-:0;79660:13;:11;:13::i;:::-;86752:10:::1;:24:::0;86678:106::o;89653:244::-;89820:4;-1:-1:-1;;;;;5708:18:0;;5716:10;5708:18;5704:83;;5743:32;5764:10;5743:20;:32::i;:::-;89842:47:::1;89865:4;89871:2;89875:7;89884:4;89842:22;:47::i;:::-;89653:244:::0;;;;;:::o;84328:310::-;79660:13;:11;:13::i;:::-;84427:9:::1;84422:209;84446:9;:16;84442:1;:20;84422:209;;;84489:9;84484:136;84508:11;84504:1;:15;84484:136;;;84545:22;84554:9;84564:1;84554:12;;;;;;;;:::i;:::-;;;;;;;84545:8;:22::i;:::-;84586:16;:18:::0;;;:16:::1;:18;::::0;::::1;:::i;:::-;;;;;;84521:3;;;;;:::i;:::-;;;;84484:136;;;-1:-1:-1::0;84464:3:0;::::1;::::0;::::1;:::i;:::-;;;;84422:209;;87924:220:::0;88051:13;88103:23;88118:7;88103:14;:23::i;:::-;88089:47;;;;;;;;:::i;:::-;;;;;;;;;;;;;88082:54;;87924:220;;;:::o;87208:82::-;79660:13;:11;:13::i;:::-;87270:4:::1;:12:::0;;-1:-1:-1;;;;;;87270:12:0::1;-1:-1:-1::0;;;;;87270:12:0;;;::::1;::::0;;;::::1;::::0;;87208:82::o;85966:560::-;86090:5;;86082:34;;-1:-1:-1;;;86082:34:0;;-1:-1:-1;;;;;1879:32:1;;;86082:34:0;;;1861:51:1;86027:16:0;;86056:23;;86090:5;;;86082:24;;1834:18:1;;86082:34:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;86056:60;;86127:25;86169:15;86155:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;86155:30:0;;86127:58;;86196:10;86226:9;86221:272;86241:15;86237:1;:19;86221:272;;;86315:5;;86297:57;;-1:-1:-1;;;86297:57:0;;-1:-1:-1;;;;;3285:32:1;;;86297:57:0;;;3267:51:1;3334:18;;;3327:34;;;86278:16:0;;86315:5;;86297:44;;3240:18:1;;86297:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;86373:26;;;;:16;:26;;;;;;86278:76;;-1:-1:-1;86373:26:0;;86369:113;;86435:8;86420;86429:2;86420:12;;;;;;;;:::i;:::-;;;;;;;;;;:23;86462:4;;;;:::i;:::-;;;;86369:113;-1:-1:-1;86258:3:0;;;;:::i;:::-;;;;86221:272;;;-1:-1:-1;86510:8:0;;85966:560;-1:-1:-1;;;;85966:560:0:o;80680:201::-;79660:13;:11;:13::i;:::-;-1:-1:-1;;;;;80769:22:0;::::1;80761:73;;;::::0;-1:-1:-1;;;80761:73:0;;18385:2:1;80761:73:0::1;::::0;::::1;18367:21:1::0;18424:2;18404:18;;;18397:30;18463:34;18443:18;;;18436:62;-1:-1:-1;;;18514:18:1;;;18507:36;18560:19;;80761:73:0::1;18183:402:1::0;80761:73:0::1;80845:28;80864:8;80845:18;:28::i;81917:33::-:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;68386:170::-;68488:4;68512:36;68536:11;68512:23;:36::i;63725:135::-;57393:4;56991:16;;;:7;:16;;;;;;-1:-1:-1;;;;;56991:16:0;63799:53;;;;-1:-1:-1;;;63799:53:0;;16204:2:1;63799:53:0;;;16186:21:1;16243:2;16223:18;;;16216:30;-1:-1:-1;;;16262:18:1;;;16255:54;16326:18;;63799:53:0;16002:348:1;5946:419:0;4467:42;6137:45;:49;6133:225;;6208:67;;-1:-1:-1;;;6208:67:0;;6259:4;6208:67;;;18802:34:1;-1:-1:-1;;;;;18872:15:1;;18852:18;;;18845:43;4467:42:0;;6208;;18737:18:1;;6208:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;6203:144;;6303:28;;-1:-1:-1;;;6303:28:0;;-1:-1:-1;;;;;1879:32:1;;6303:28:0;;;1861:51:1;1834:18;;6303:28:0;1715:203:1;53424:416:0;53505:13;53521:23;53536:7;53521:14;:23::i;:::-;53505:39;;53569:5;-1:-1:-1;;;;;53563:11:0;:2;-1:-1:-1;;;;;53563:11:0;;53555:57;;;;-1:-1:-1;;;53555:57:0;;19351:2:1;53555:57:0;;;19333:21:1;19390:2;19370:18;;;19363:30;19429:34;19409:18;;;19402:62;-1:-1:-1;;;19480:18:1;;;19473:31;19521:19;;53555:57:0;19149:397:1;53555:57:0;47270:10;-1:-1:-1;;;;;53647:21:0;;;;:62;;-1:-1:-1;53672:37:0;53689:5;47270:10;54375:164;:::i;53672:37::-;53625:173;;;;-1:-1:-1;;;53625:173:0;;19753:2:1;53625:173:0;;;19735:21:1;19792:2;19772:18;;;19765:30;19831:34;19811:18;;;19804:62;19902:31;19882:18;;;19875:59;19951:19;;53625:173:0;19551:425:1;53625:173:0;53811:21;53820:2;53824:7;53811:8;:21::i;79939:132::-;79847:6;;-1:-1:-1;;;;;79847:6:0;;;;;47270:10;80003:23;79995:68;;;;-1:-1:-1;;;79995:68:0;;20183:2:1;79995:68:0;;;20165:21:1;;;20202:18;;;20195:30;20261:34;20241:18;;;20234:62;20313:18;;79995:68:0;19981:356:1;54606:335:0;54801:41;47270:10;54820:12;47190:98;54801:41;54793:99;;;;-1:-1:-1;;;54793:99:0;;;;;;;:::i;:::-;54905:28;54915:4;54921:2;54925:7;54905:9;:28::i;84646:208::-;84696:15;84714:25;:15;997:14;;905:114;84714:25;:29;;84742:1;84714:29;:::i;:::-;84696:47;;84754:27;:15;1116:19;;1134:1;1116:19;;;1027:127;84754:27;84792:22;84802:2;84806:7;84792:9;:22::i;:::-;84825:21;84838:7;84825:12;:21::i;49932:120::-;48941:16;:14;:16::i;:::-;49991:7:::1;:15:::0;;-1:-1:-1;;49991:15:0::1;::::0;;50022:22:::1;47270:10:::0;50031:12:::1;50022:22;::::0;-1:-1:-1;;;;;1879:32:1;;;1861:51;;1849:2;1834:18;50022:22:0::1;;;;;;;49932:120::o:0;55012:185::-;55150:39;55167:4;55173:2;55177:7;55150:39;;;;;;;;;;;;:16;:39::i;57623:264::-;57716:4;57733:13;57749:23;57764:7;57749:14;:23::i;:::-;57733:39;;57802:5;-1:-1:-1;;;;;57791:16:0;:7;-1:-1:-1;;;;;57791:16:0;;:52;;;-1:-1:-1;;;;;;54496:25:0;;;54472:4;54496:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;57811:32;57791:87;;;;57871:7;-1:-1:-1;;;;;57847:31:0;:20;57859:7;57847:11;:20::i;:::-;-1:-1:-1;;;;;57847:31:0;;57791:87;57783:96;57623:264;-1:-1:-1;;;;57623:264:0:o;87786:130::-;87888:20;87900:7;87888:11;:20::i;81041:191::-;81134:6;;;-1:-1:-1;;;;;81151:17:0;;;81134:6;81151:17;;;-1:-1:-1;;;;;;81151:17:0;;;;;;81184:40;;81134:6;;;;;;;;81184:40;;81115:16;;81184:40;81104:128;81041:191;:::o;49673:118::-;48682:19;:17;:19::i;:::-;49733:7:::1;:14:::0;;-1:-1:-1;;49733:14:0::1;49743:4;49733:14;::::0;;49763:20:::1;49770:12;47270:10:::0;;47190:98;38109:332;37825:5;-1:-1:-1;;;;;38212:33:0;;;;38204:88;;;;-1:-1:-1;;;38204:88:0;;20544:2:1;38204:88:0;;;20526:21:1;20583:2;20563:18;;;20556:30;20622:34;20602:18;;;20595:62;-1:-1:-1;;;20673:18:1;;;20666:40;20723:19;;38204:88:0;20342:406:1;38204:88:0;-1:-1:-1;;;;;38311:22:0;;38303:60;;;;-1:-1:-1;;;38303:60:0;;20955:2:1;38303:60:0;;;20937:21:1;20994:2;20974:18;;;20967:30;21033:27;21013:18;;;21006:55;21078:18;;38303:60:0;20753:349:1;38303:60:0;38398:35;;;;;;;;;-1:-1:-1;;;;;38398:35:0;;;;;;-1:-1:-1;;;;;38398:35:0;;;;;;;;;;-1:-1:-1;;;38376:57:0;;;;-1:-1:-1;38376:57:0;38109:332::o;54149:155::-;54244:52;47270:10;54277:8;54287;54244:18;:52::i;55268:322::-;55442:41;47270:10;55475:7;55442:18;:41::i;:::-;55434:99;;;;-1:-1:-1;;;55434:99:0;;;;;;;:::i;:::-;55544:38;55558:4;55564:2;55568:7;55577:4;55544:13;:38::i;70143:624::-;70216:13;70242:23;70257:7;70242:14;:23::i;:::-;70278;70304:19;;;:10;:19;;;;;70278:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70334:18;70355:10;:8;:10::i;:::-;70334:31;;70447:4;70441:18;70463:1;70441:23;70437:72;;-1:-1:-1;70488:9:0;70143:624;-1:-1:-1;;70143:624:0:o;70437:72::-;70613:23;;:27;70609:108;;70688:4;70694:9;70671:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;70657:48;;;;70143:624;;;:::o;70609:108::-;70736:23;70751:7;70736:14;:23::i;72604:224::-;72706:4;-1:-1:-1;;;;;;72730:50:0;;-1:-1:-1;;;72730:50:0;;:90;;;72784:36;72808:11;72784:23;:36::i;63004:174::-;63079:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;63079:29:0;-1:-1:-1;;;;;63079:29:0;;;;;;;;:24;;63133:23;63079:24;63133:14;:23::i;:::-;-1:-1:-1;;;;;63124:46:0;;;;;;;;;;;63004:174;;:::o;61622:1263::-;61781:4;-1:-1:-1;;;;;61754:31:0;:23;61769:7;61754:14;:23::i;:::-;-1:-1:-1;;;;;61754:31:0;;61746:81;;;;-1:-1:-1;;;61746:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;61846:16:0;;61838:65;;;;-1:-1:-1;;;61838:65:0;;22216:2:1;61838:65:0;;;22198:21:1;22255:2;22235:18;;;22228:30;22294:34;22274:18;;;22267:62;-1:-1:-1;;;22345:18:1;;;22338:34;22389:19;;61838:65:0;22014:400:1;61838:65:0;61916:42;61937:4;61943:2;61947:7;61956:1;61916:20;:42::i;:::-;62088:4;-1:-1:-1;;;;;62061:31:0;:23;62076:7;62061:14;:23::i;:::-;-1:-1:-1;;;;;62061:31:0;;62053:81;;;;-1:-1:-1;;;62053:81:0;;;;;;;:::i;:::-;62206:24;;;;:15;:24;;;;;;;;62199:31;;-1:-1:-1;;;;;;62199:31:0;;;;;;-1:-1:-1;;;;;62682:15:0;;;;;;:9;:15;;;;;:20;;-1:-1:-1;;62682:20:0;;;62717:13;;;;;;;;;:18;;62199:31;62717:18;;;62757:16;;;:7;:16;;;;;;:21;;;;;;;;;;62796:27;;62222:7;;62796:27;;;88985:208;;;:::o;58229:110::-;58305:26;58315:2;58319:7;58305:26;;;;;;;;;;;;:9;:26::i;88152:354::-;57393:4;56991:16;;;:7;:16;;;;;;-1:-1:-1;;;;;56991:16:0;88219:73;;;;-1:-1:-1;;;88219:73:0;;22621:2:1;88219:73:0;;;22603:21:1;22660:2;22640:18;;;22633:30;22699:34;22679:18;;;22672:62;-1:-1:-1;;;22750:18:1;;;22743:42;22802:19;;88219:73:0;22419:408:1;88219:73:0;88303:20;88340:25;88357:7;88340:16;:25::i;:::-;88326:49;;;;;;;;:::i;:::-;;;;;;;;;;;;;88303:72;;88386:23;88436:10;:8;:10::i;:::-;88448:6;88419:36;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;88419:36:0;;;;;;;;;88467:19;;;;:10;88419:36;88467:19;;88419:36;;-1:-1:-1;88467:31:0;88419:36;88467:19;:31;:::i;49421:108::-;49148:7;;;;49480:41;;;;-1:-1:-1;;;49480:41:0;;23034:2:1;49480:41:0;;;23016:21:1;23073:2;23053:18;;;23046:30;-1:-1:-1;;;23092:18:1;;;23085:50;23152:18;;49480:41:0;22832:344:1;68688:135:0;68757:20;68769:7;68757:11;:20::i;:::-;39473:26;;;;:17;:26;;;;;39466:33;87298:147::o;49236:108::-;49148:7;;;;49306:9;49298:38;;;;-1:-1:-1;;;49298:38:0;;23383:2:1;49298:38:0;;;23365:21:1;23422:2;23402:18;;;23395:30;-1:-1:-1;;;23441:18:1;;;23434:46;23497:18;;49298:38:0;23181:340:1;63321:315:0;63476:8;-1:-1:-1;;;;;63467:17:0;:5;-1:-1:-1;;;;;63467:17:0;;63459:55;;;;-1:-1:-1;;;63459:55:0;;23728:2:1;63459:55:0;;;23710:21:1;23767:2;23747:18;;;23740:30;23806:27;23786:18;;;23779:55;23851:18;;63459:55:0;23526:349:1;63459:55:0;-1:-1:-1;;;;;63525:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;63525:46:0;;;;;;;;;;63587:41;;540::1;;;63587::0;;513:18:1;63587:41:0;;;;;;;63321:315;;;:::o;56471:313::-;56627:28;56637:4;56643:2;56647:7;56627:9;:28::i;:::-;56674:47;56697:4;56703:2;56707:7;56716:4;56674:22;:47::i;:::-;56666:110;;;;-1:-1:-1;;;56666:110:0;;;;;;;:::i;82358:100::-;82410:13;82443:7;82436:14;;;;;:::i;52738:281::-;52811:13;52837:23;52852:7;52837:14;:23::i;:::-;52873:21;52897:10;:8;:10::i;:::-;52873:34;;52949:1;52931:7;52925:21;:25;:86;;;;;;;;;;;;;;;;;52977:7;52986:18;:7;:16;:18::i;:::-;52960:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;52925:86;52918:93;52738:281;-1:-1:-1;;;52738:281:0:o;51466:305::-;51568:4;-1:-1:-1;;;;;;51605:40:0;;-1:-1:-1;;;51605:40:0;;:105;;-1:-1:-1;;;;;;;51662:48:0;;-1:-1:-1;;;51662:48:0;51605:105;:158;;;;51727:36;51751:11;51727:23;:36::i;87453:257::-;48682:19;:17;:19::i;:::-;87646:56:::1;87673:4;87679:2;87683:7;87692:9;87646:26;:56::i;58566:319::-:0;58695:18;58701:2;58705:7;58695:5;:18::i;:::-;58746:53;58777:1;58781:2;58785:7;58794:4;58746:22;:53::i;:::-;58724:153;;;;-1:-1:-1;;;58724:153:0;;;;;;;:::i;20141:716::-;20197:13;20248:14;20265:17;20276:5;20265:10;:17::i;:::-;20285:1;20265:21;20248:38;;20301:20;20335:6;20324:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;20324:18:0;-1:-1:-1;20301:41:0;-1:-1:-1;20466:28:0;;;20482:2;20466:28;20523:288;-1:-1:-1;;20555:5:0;-1:-1:-1;;;20692:2:0;20681:14;;20676:30;20555:5;20663:44;20753:2;20744:11;;;-1:-1:-1;20774:21:0;20523:288;20774:21;-1:-1:-1;20832:6:0;20141:716;-1:-1:-1;;;20141:716:0:o;71365:206::-;71434:20;71446:7;71434:11;:20::i;:::-;71477:19;;;;:10;:19;;;;;71471:33;;;;;:::i;:::-;:38;;-1:-1:-1;71467:97:0;;71533:19;;;;:10;:19;;;;;71526:26;;;:::i;64424:853::-;64578:4;-1:-1:-1;;;;;64599:13:0;;23563:19;:23;64595:675;;64635:71;;-1:-1:-1;;;64635:71:0;;-1:-1:-1;;;;;64635:36:0;;;;;:71;;47270:10;;64686:4;;64692:7;;64701:4;;64635:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;64635:71:0;;;;;;;;-1:-1:-1;;64635:71:0;;;;;;;;;;;;:::i;:::-;;;64631:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64876:6;:13;64893:1;64876:18;64872:328;;64919:60;;-1:-1:-1;;;64919:60:0;;;;;;;:::i;64872:328::-;65150:6;65144:13;65135:6;65131:2;65127:15;65120:38;64631:584;-1:-1:-1;;;;;;64757:51:0;-1:-1:-1;;;64757:51:0;;-1:-1:-1;64750:58:0;;64595:675;-1:-1:-1;65254:4:0;64424:853;;;;;;:::o;36747:215::-;36849:4;-1:-1:-1;;;;;;36873:41:0;;-1:-1:-1;;;36873:41:0;;:81;;-1:-1:-1;;;;;;;;;;35306:40:0;;;36918:36;35197:157;73741:915;73918:61;73945:4;73951:2;73955:12;73969:9;73918:26;:61::i;:::-;74008:1;73996:9;:13;73992:222;;;74139:63;;-1:-1:-1;;;74139:63:0;;25249:2:1;74139:63:0;;;25231:21:1;25288:2;25268:18;;;25261:30;25327:34;25307:18;;;25300:62;-1:-1:-1;;;25378:18:1;;;25371:51;25439:19;;74139:63:0;25047:417:1;73992:222:0;74244:12;-1:-1:-1;;;;;74273:18:0;;74269:187;;74308:40;74340:7;75483:10;:17;;75456:24;;;;:15;:24;;;;;:44;;;75511:24;;;;;;;;;;;;75379:164;74308:40;74269:187;;;74378:2;-1:-1:-1;;;;;74370:10:0;:4;-1:-1:-1;;;;;74370:10:0;;74366:90;;74397:47;74430:4;74436:7;74397:32;:47::i;:::-;-1:-1:-1;;;;;74470:16:0;;74466:183;;74503:45;74540:7;74503:36;:45::i;:::-;74466:183;;;74576:4;-1:-1:-1;;;;;74570:10:0;:2;-1:-1:-1;;;;;74570:10:0;;74566:83;;74597:40;74625:2;74629:7;74597:27;:40::i;59221:942::-;-1:-1:-1;;;;;59301:16:0;;59293:61;;;;-1:-1:-1;;;59293:61:0;;25671:2:1;59293:61:0;;;25653:21:1;;;25690:18;;;25683:30;25749:34;25729:18;;;25722:62;25801:18;;59293:61:0;25469:356:1;59293:61:0;57393:4;56991:16;;;:7;:16;;;;;;-1:-1:-1;;;;;56991:16:0;57417:31;59365:58;;;;-1:-1:-1;;;59365:58:0;;26032:2:1;59365:58:0;;;26014:21:1;26071:2;26051:18;;;26044:30;26110;26090:18;;;26083:58;26158:18;;59365:58:0;25830:352:1;59365:58:0;59436:48;59465:1;59469:2;59473:7;59482:1;59436:20;:48::i;:::-;57393:4;56991:16;;;:7;:16;;;;;;-1:-1:-1;;;;;56991:16:0;57417:31;59574:58;;;;-1:-1:-1;;;59574:58:0;;26032:2:1;59574:58:0;;;26014:21:1;26071:2;26051:18;;;26044:30;26110;26090:18;;;26083:58;26158:18;;59574:58:0;25830:352:1;59574:58:0;-1:-1:-1;;;;;59981:13:0;;;;;;:9;:13;;;;;;;;:18;;59998:1;59981:18;;;60023:16;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;60023:21:0;;;;;60062:33;60031:7;;59981:13;;60062:33;;59981:13;;60062:33;83030:307;82847:497;:::o;17007:922::-;17060:7;;-1:-1:-1;;;17138:15:0;;17134:102;;-1:-1:-1;;;17174:15:0;;;-1:-1:-1;17218:2:0;17208:12;17134:102;17263:6;17254:5;:15;17250:102;;17299:6;17290:15;;;-1:-1:-1;17334:2:0;17324:12;17250:102;17379:6;17370:5;:15;17366:102;;17415:6;17406:15;;;-1:-1:-1;17450:2:0;17440:12;17366:102;17495:5;17486;:14;17482:99;;17530:5;17521:14;;;-1:-1:-1;17564:1:0;17554:11;17482:99;17608:5;17599;:14;17595:99;;17643:5;17634:14;;;-1:-1:-1;17677:1:0;17667:11;17595:99;17721:5;17712;:14;17708:99;;17756:5;17747:14;;;-1:-1:-1;17790:1:0;17780:11;17708:99;17834:5;17825;:14;17821:66;;17870:1;17860:11;17915:6;17007:922;-1:-1:-1;;17007:922:0:o;60502:783::-;60562:13;60578:23;60593:7;60578:14;:23::i;:::-;60562:39;;60614:51;60635:5;60650:1;60654:7;60663:1;60614:20;:51::i;:::-;60778:23;60793:7;60778:14;:23::i;:::-;60849:24;;;;:15;:24;;;;;;;;60842:31;;-1:-1:-1;;;;;;60842:31:0;;;;;;-1:-1:-1;;;;;61094:16:0;;;;;:9;:16;;;;;:21;;-1:-1:-1;;61094:21:0;;;61144:16;;;:7;:16;;;;;;61137:23;;;;;;;61178:36;60770:31;;-1:-1:-1;60865:7:0;;61178:36;;60849:24;;61178:36;83030:307;82847:497;:::o;66009:410::-;66199:1;66187:9;:13;66183:229;;;-1:-1:-1;;;;;66221:18:0;;;66217:87;;-1:-1:-1;;;;;66260:15:0;;;;;;:9;:15;;;;;:28;;66279:9;;66260:15;:28;;66279:9;;66260:28;:::i;:::-;;;;-1:-1:-1;;66217:87:0;-1:-1:-1;;;;;66322:16:0;;;66318:83;;-1:-1:-1;;;;;66359:13:0;;;;;;:9;:13;;;;;:26;;66376:9;;66359:13;:26;;66376:9;;66359:26;:::i;:::-;;;;-1:-1:-1;;66009:410:0;;;;:::o;76170:988::-;76436:22;76486:1;76461:22;76478:4;76461:16;:22::i;:::-;:26;;;;:::i;:::-;76498:18;76519:26;;;:17;:26;;;;;;76436:51;;-1:-1:-1;76652:28:0;;;76648:328;;-1:-1:-1;;;;;76719:18:0;;76697:19;76719:18;;;:12;:18;;;;;;;;:34;;;;;;;;;76770:30;;;;;;:44;;;76887:30;;:17;:30;;;;;:43;;;76648:328;-1:-1:-1;77072:26:0;;;;:17;:26;;;;;;;;77065:33;;;-1:-1:-1;;;;;77116:18:0;;;;;:12;:18;;;;;:34;;;;;;;77109:41;76170:988::o;77453:1079::-;77731:10;:17;77706:22;;77731:21;;77751:1;;77731:21;:::i;:::-;77763:18;77784:24;;;:15;:24;;;;;;78157:10;:26;;77706:46;;-1:-1:-1;77784:24:0;;77706:46;;78157:26;;;;;;:::i;:::-;;;;;;;;;78135:48;;78221:11;78196:10;78207;78196:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;78301:28;;;:15;:28;;;;;;;:41;;;78473:24;;;;;78466:31;78508:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;77524:1008;;;77453:1079;:::o;74957:221::-;75042:14;75059:20;75076:2;75059:16;:20::i;:::-;-1:-1:-1;;;;;75090:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;75135:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;74957:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;774:250::-;859:1;869:113;883:6;880:1;877:13;869:113;;;959:11;;;953:18;940:11;;;933:39;905:2;898:10;869:113;;;-1:-1:-1;;1016:1:1;998:16;;991:27;774:250::o;1029:271::-;1071:3;1109:5;1103:12;1136:6;1131:3;1124:19;1152:76;1221:6;1214:4;1209:3;1205:14;1198:4;1191:5;1187:16;1152:76;:::i;:::-;1282:2;1261:15;-1:-1:-1;;1257:29:1;1248:39;;;;1289:4;1244:50;;1029:271;-1:-1:-1;;1029:271:1:o;1305:220::-;1454:2;1443:9;1436:21;1417:4;1474:45;1515:2;1504:9;1500:18;1492:6;1474:45;:::i;1530:180::-;1589:6;1642:2;1630:9;1621:7;1617:23;1613:32;1610:52;;;1658:1;1655;1648:12;1610:52;-1:-1:-1;1681:23:1;;1530:180;-1:-1:-1;1530:180:1:o;1923:131::-;-1:-1:-1;;;;;1998:31:1;;1988:42;;1978:70;;2044:1;2041;2034:12;2059:315;2127:6;2135;2188:2;2176:9;2167:7;2163:23;2159:32;2156:52;;;2204:1;2201;2194:12;2156:52;2243:9;2230:23;2262:31;2287:5;2262:31;:::i;:::-;2312:5;2364:2;2349:18;;;;2336:32;;-1:-1:-1;;;2059:315:1:o;2379:456::-;2456:6;2464;2472;2525:2;2513:9;2504:7;2500:23;2496:32;2493:52;;;2541:1;2538;2531:12;2493:52;2580:9;2567:23;2599:31;2624:5;2599:31;:::i;:::-;2649:5;-1:-1:-1;2706:2:1;2691:18;;2678:32;2719:33;2678:32;2719:33;:::i;:::-;2379:456;;2771:7;;-1:-1:-1;;;2825:2:1;2810:18;;;;2797:32;;2379:456::o;2840:248::-;2908:6;2916;2969:2;2957:9;2948:7;2944:23;2940:32;2937:52;;;2985:1;2982;2975:12;2937:52;-1:-1:-1;;3008:23:1;;;3078:2;3063:18;;;3050:32;;-1:-1:-1;2840:248:1:o;3372:127::-;3433:10;3428:3;3424:20;3421:1;3414:31;3464:4;3461:1;3454:15;3488:4;3485:1;3478:15;3504:275;3575:2;3569:9;3640:2;3621:13;;-1:-1:-1;;3617:27:1;3605:40;;3675:18;3660:34;;3696:22;;;3657:62;3654:88;;;3722:18;;:::i;:::-;3758:2;3751:22;3504:275;;-1:-1:-1;3504:275:1:o;3784:183::-;3844:4;3877:18;3869:6;3866:30;3863:56;;;3899:18;;:::i;:::-;-1:-1:-1;3944:1:1;3940:14;3956:4;3936:25;;3784:183::o;3972:891::-;4056:6;4087:2;4130;4118:9;4109:7;4105:23;4101:32;4098:52;;;4146:1;4143;4136:12;4098:52;4186:9;4173:23;4219:18;4211:6;4208:30;4205:50;;;4251:1;4248;4241:12;4205:50;4274:22;;4327:4;4319:13;;4315:27;-1:-1:-1;4305:55:1;;4356:1;4353;4346:12;4305:55;4392:2;4379:16;4415:60;4431:43;4471:2;4431:43;:::i;:::-;4415:60;:::i;:::-;4509:15;;;4591:1;4587:10;;;;4579:19;;4575:28;;;4540:12;;;;4615:19;;;4612:39;;;4647:1;4644;4637:12;4612:39;4671:11;;;;4691:142;4707:6;4702:3;4699:15;4691:142;;;4773:17;;4761:30;;4724:12;;;;4811;;;;4691:142;;;4852:5;3972:891;-1:-1:-1;;;;;;;3972:891:1:o;4868:247::-;4927:6;4980:2;4968:9;4959:7;4955:23;4951:32;4948:52;;;4996:1;4993;4986:12;4948:52;5035:9;5022:23;5054:31;5079:5;5054:31;:::i;5359:632::-;5530:2;5582:21;;;5652:13;;5555:18;;;5674:22;;;5501:4;;5530:2;5753:15;;;;5727:2;5712:18;;;5501:4;5796:169;5810:6;5807:1;5804:13;5796:169;;;5871:13;;5859:26;;5940:15;;;;5905:12;;;;5832:1;5825:9;5796:169;;;-1:-1:-1;5982:3:1;;5359:632;-1:-1:-1;;;;;;5359:632:1:o;5996:407::-;6061:5;6095:18;6087:6;6084:30;6081:56;;;6117:18;;:::i;:::-;6155:57;6200:2;6179:15;;-1:-1:-1;;6175:29:1;6206:4;6171:40;6155:57;:::i;:::-;6146:66;;6235:6;6228:5;6221:21;6275:3;6266:6;6261:3;6257:16;6254:25;6251:45;;;6292:1;6289;6282:12;6251:45;6341:6;6336:3;6329:4;6322:5;6318:16;6305:43;6395:1;6388:4;6379:6;6372:5;6368:18;6364:29;6357:40;5996:407;;;;;:::o;6408:451::-;6477:6;6530:2;6518:9;6509:7;6505:23;6501:32;6498:52;;;6546:1;6543;6536:12;6498:52;6586:9;6573:23;6619:18;6611:6;6608:30;6605:50;;;6651:1;6648;6641:12;6605:50;6674:22;;6727:4;6719:13;;6715:27;-1:-1:-1;6705:55:1;;6756:1;6753;6746:12;6705:55;6779:74;6845:7;6840:2;6827:16;6822:2;6818;6814:11;6779:74;:::i;6864:435::-;6931:6;6939;6992:2;6980:9;6971:7;6967:23;6963:32;6960:52;;;7008:1;7005;6998:12;6960:52;7047:9;7034:23;7066:31;7091:5;7066:31;:::i;:::-;7116:5;-1:-1:-1;7173:2:1;7158:18;;7145:32;-1:-1:-1;;;;;7208:40:1;;7196:53;;7186:81;;7263:1;7260;7253:12;7186:81;7286:7;7276:17;;;6864:435;;;;;:::o;7304:118::-;7390:5;7383:13;7376:21;7369:5;7366:32;7356:60;;7412:1;7409;7402:12;7427:382;7492:6;7500;7553:2;7541:9;7532:7;7528:23;7524:32;7521:52;;;7569:1;7566;7559:12;7521:52;7608:9;7595:23;7627:31;7652:5;7627:31;:::i;:::-;7677:5;-1:-1:-1;7734:2:1;7719:18;;7706:32;7747:30;7706:32;7747:30;:::i;7814:795::-;7909:6;7917;7925;7933;7986:3;7974:9;7965:7;7961:23;7957:33;7954:53;;;8003:1;8000;7993:12;7954:53;8042:9;8029:23;8061:31;8086:5;8061:31;:::i;:::-;8111:5;-1:-1:-1;8168:2:1;8153:18;;8140:32;8181:33;8140:32;8181:33;:::i;:::-;8233:7;-1:-1:-1;8287:2:1;8272:18;;8259:32;;-1:-1:-1;8342:2:1;8327:18;;8314:32;8369:18;8358:30;;8355:50;;;8401:1;8398;8391:12;8355:50;8424:22;;8477:4;8469:13;;8465:27;-1:-1:-1;8455:55:1;;8506:1;8503;8496:12;8455:55;8529:74;8595:7;8590:2;8577:16;8572:2;8568;8564:11;8529:74;:::i;:::-;8519:84;;;7814:795;;;;;;;:::o;8614:1036::-;8707:6;8715;8768:2;8756:9;8747:7;8743:23;8739:32;8736:52;;;8784:1;8781;8774:12;8736:52;8824:9;8811:23;8857:18;8849:6;8846:30;8843:50;;;8889:1;8886;8879:12;8843:50;8912:22;;8965:4;8957:13;;8953:27;-1:-1:-1;8943:55:1;;8994:1;8991;8984:12;8943:55;9030:2;9017:16;9052:4;9076:60;9092:43;9132:2;9092:43;:::i;9076:60::-;9170:15;;;9252:1;9248:10;;;;9240:19;;9236:28;;;9201:12;;;;9276:19;;;9273:39;;;9308:1;9305;9298:12;9273:39;9332:11;;;;9352:217;9368:6;9363:3;9360:15;9352:217;;;9448:3;9435:17;9465:31;9490:5;9465:31;:::i;:::-;9509:18;;9385:12;;;;9547;;;;9352:217;;;9588:5;9625:18;;;;9612:32;;-1:-1:-1;;;;;;8614:1036:1:o;9655:388::-;9723:6;9731;9784:2;9772:9;9763:7;9759:23;9755:32;9752:52;;;9800:1;9797;9790:12;9752:52;9839:9;9826:23;9858:31;9883:5;9858:31;:::i;:::-;9908:5;-1:-1:-1;9965:2:1;9950:18;;9937:32;9978:33;9937:32;9978:33;:::i;10048:380::-;10127:1;10123:12;;;;10170;;;10191:61;;10245:4;10237:6;10233:17;10223:27;;10191:61;10298:2;10290:6;10287:14;10267:18;10264:38;10261:161;;10344:10;10339:3;10335:20;10332:1;10325:31;10379:4;10376:1;10369:15;10407:4;10404:1;10397:15;10261:161;;10048:380;;;:::o;10433:184::-;10503:6;10556:2;10544:9;10535:7;10531:23;10527:32;10524:52;;;10572:1;10569;10562:12;10524:52;-1:-1:-1;10595:16:1;;10433:184;-1:-1:-1;10433:184:1:o;10622:127::-;10683:10;10678:3;10674:20;10671:1;10664:31;10714:4;10711:1;10704:15;10738:4;10735:1;10728:15;10754:168;10827:9;;;10858;;10875:15;;;10869:22;;10855:37;10845:71;;10896:18;;:::i;11059:217::-;11099:1;11125;11115:132;;11169:10;11164:3;11160:20;11157:1;11150:31;11204:4;11201:1;11194:15;11232:4;11229:1;11222:15;11115:132;-1:-1:-1;11261:9:1;;11059:217::o;11693:125::-;11758:9;;;11779:10;;;11776:36;;;11792:18;;:::i;11823:405::-;12025:2;12007:21;;;12064:2;12044:18;;;12037:30;12103:34;12098:2;12083:18;;12076:62;-1:-1:-1;;;12169:2:1;12154:18;;12147:39;12218:3;12203:19;;11823:405::o;12233:127::-;12294:10;12289:3;12285:20;12282:1;12275:31;12325:4;12322:1;12315:15;12349:4;12346:1;12339:15;12365:251;12435:6;12488:2;12476:9;12467:7;12463:23;12459:32;12456:52;;;12504:1;12501;12494:12;12456:52;12536:9;12530:16;12555:31;12580:5;12555:31;:::i;12621:135::-;12660:3;12681:17;;;12678:43;;12701:18;;:::i;:::-;-1:-1:-1;12748:1:1;12737:13;;12621:135::o;12971:409::-;13173:2;13155:21;;;13212:2;13192:18;;;13185:30;13251:34;13246:2;13231:18;;13224:62;-1:-1:-1;;;13317:2:1;13302:18;;13295:43;13370:3;13355:19;;12971:409::o;13924:545::-;14026:2;14021:3;14018:11;14015:448;;;14062:1;14087:5;14083:2;14076:17;14132:4;14128:2;14118:19;14202:2;14190:10;14186:19;14183:1;14179:27;14173:4;14169:38;14238:4;14226:10;14223:20;14220:47;;;-1:-1:-1;14261:4:1;14220:47;14316:2;14311:3;14307:12;14304:1;14300:20;14294:4;14290:31;14280:41;;14371:82;14389:2;14382:5;14379:13;14371:82;;;14434:17;;;14415:1;14404:13;14371:82;;;14375:3;;;13924:545;;;:::o;14645:1352::-;14771:3;14765:10;14798:18;14790:6;14787:30;14784:56;;;14820:18;;:::i;:::-;14849:97;14939:6;14899:38;14931:4;14925:11;14899:38;:::i;:::-;14893:4;14849:97;:::i;:::-;15001:4;;15065:2;15054:14;;15082:1;15077:663;;;;15784:1;15801:6;15798:89;;;-1:-1:-1;15853:19:1;;;15847:26;15798:89;-1:-1:-1;;14602:1:1;14598:11;;;14594:24;14590:29;14580:40;14626:1;14622:11;;;14577:57;15900:81;;15047:944;;15077:663;13871:1;13864:14;;;13908:4;13895:18;;-1:-1:-1;;15113:20:1;;;15231:236;15245:7;15242:1;15239:14;15231:236;;;15334:19;;;15328:26;15313:42;;15426:27;;;;15394:1;15382:14;;;;15261:19;;15231:236;;;15235:3;15495:6;15486:7;15483:19;15480:201;;;15556:19;;;15550:26;-1:-1:-1;;15639:1:1;15635:14;;;15651:3;15631:24;15627:37;15623:42;15608:58;15593:74;;15480:201;-1:-1:-1;;;;;15727:1:1;15711:14;;;15707:22;15694:36;;-1:-1:-1;14645:1352:1:o;16765:265::-;-1:-1:-1;;;;;16894:10:1;;;16906;;;16890:27;16937:20;;;;16836:26;16976:24;;;16966:58;;17004:18;;:::i;:::-;16966:58;;16765:265;;;;:::o;17733:445::-;17954:3;17992:6;17986:13;18008:66;18067:6;18062:3;18055:4;18047:6;18043:17;18008:66;:::i;:::-;-1:-1:-1;;;18096:16:1;;18121:22;;;-1:-1:-1;18170:1:1;18159:13;;17733:445;-1:-1:-1;17733:445:1:o;18899:245::-;18966:6;19019:2;19007:9;18998:7;18994:23;18990:32;18987:52;;;19035:1;19032;19025:12;18987:52;19067:9;19061:16;19086:28;19108:5;19086:28;:::i;21107:496::-;21286:3;21324:6;21318:13;21340:66;21399:6;21394:3;21387:4;21379:6;21375:17;21340:66;:::i;:::-;21469:13;;21428:16;;;;21491:70;21469:13;21428:16;21538:4;21526:17;;21491:70;:::i;:::-;21577:20;;21107:496;-1:-1:-1;;;;21107:496:1:o;21608:401::-;21810:2;21792:21;;;21849:2;21829:18;;;21822:30;21888:34;21883:2;21868:18;;21861:62;-1:-1:-1;;;21954:2:1;21939:18;;21932:35;21999:3;21984:19;;21608:401::o;23880:414::-;24082:2;24064:21;;;24121:2;24101:18;;;24094:30;24160:34;24155:2;24140:18;;24133:62;-1:-1:-1;;;24226:2:1;24211:18;;24204:48;24284:3;24269:19;;23880:414::o;24299:489::-;-1:-1:-1;;;;;24568:15:1;;;24550:34;;24620:15;;24615:2;24600:18;;24593:43;24667:2;24652:18;;24645:34;;;24715:3;24710:2;24695:18;;24688:31;;;24493:4;;24736:46;;24762:19;;24754:6;24736:46;:::i;:::-;24728:54;24299:489;-1:-1:-1;;;;;;24299:489:1:o;24793:249::-;24862:6;24915:2;24903:9;24894:7;24890:23;24886:32;24883:52;;;24931:1;24928;24921:12;24883:52;24963:9;24957:16;24982:30;25006:5;24982:30;:::i;26187:128::-;26254:9;;;26275:11;;;26272:37;;;26289:18;;:::i;26320:127::-;26381:10;26376:3;26372:20;26369:1;26362:31;26412:4;26409:1;26402:15;26436:4;26433:1;26426:15

Swarm Source

ipfs://96a31756d47c8fd9daab75e53a9a9925350b0dac3ba731156b2cd95d43ebe673

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