Token

Rifters: Outlanders (RiftersOutlanders)

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

ERC-1155

Overview

Max Total Supply

5,291 RiftersOutlanders

Holders

1,020

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xf37cb20090057bdc70b928b7f91d081d412cfe5c

Filtered by Token Holder

0xfA62FE61A7cC6d7b1e12456F96Aa256c58209D12

0xfa62fe61a7cc6d7b1e12456f96aa256c58209d12

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Outlanders

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-12
*/

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


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

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

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

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

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

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

// 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/cryptography/ECDSA.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts (last updated v4.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: @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/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/ERC1155/IERC1155Receiver.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;


/**
 * @dev _Available since v3.1._
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

// File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol


// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(address indexed account, address indexed operator, bool approved);

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) external view returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator) external view returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

// File: @openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}

// File: contracts/ERC1155D10000.sol


// Donkeverse Contracts v0.0.1
// AE THER
pragma solidity ^0.8.0;








/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
 // AE THER
contract ERC1155D is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    uint256 public constant MAX_SUPPLY = 10000;

    address[MAX_SUPPLY+1] internal _owners;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

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

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: balance query for the zero address");
        require(id < MAX_SUPPLY, "ERC1155D: id exceeds maximum");

        return _owners[id] == account ? 1 : 0;
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        require(accounts.length == ids.length, "ERC1155: accounts and ids length mismatch");

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: transfer caller is not owner nor approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        require(_owners[id] == from && amount < 2, "ERC1155: insufficient balance for transfer");

        // The ERC1155 spec allows for transfering zero tokens, but we are still expected
        // to run the other checks and emit the event. But we don't want an ownership change
        // in that case
        if (amount == 1) {
            _owners[id] = to;
        }

        emit TransferSingle(operator, from, to, id, amount);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(operator, from, to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");
        require(to != address(0), "ERC1155: transfer to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];

            require(_owners[id] == from && amounts[i] < 2, "ERC1155: insufficient balance for transfer");

            if (amounts[i] == 1) {
                _owners[id] = to;
            }
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _afterTokenTransfer(operator, from, to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(operator, from, to, ids, amounts, data);
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */

    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(amount < 2, "ERC1155D: exceeds supply");
        require(id < MAX_SUPPLY, "ERC1155D: invalid id");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        // The ERC1155 spec allows for transfering zero tokens, but we are still expected
        // to run the other checks and emit the event. But we don't want an ownership change
        // in that case
        if (amount == 1) {
            _owners[id] = to;
        }

        emit TransferSingle(operator, address(0), to, id, amount);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
    }

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `id` must be less than MAX_SUPPLY;
     * This does not implement smart contract checks according to ERC1155 so it exists as a separate function
     */

    function _mintSingle(address to, uint256 id) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address"); // you can remove this if only minting to msg.sender
        require(_owners[id] == address(0), "ERC1155D: supply exceeded");
        require(id > 0, "ERC1155D: invalid id 0"); 
        _owners[id] = to; // this can be made more efficient with assembly if you know what you are doing!
        emit TransferSingle(to, address(0), to, id, 1);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, ids, amounts, data);

        for (uint256 i = 0; i < ids.length; i++) {
            require(amounts[i] < 2, "ERC1155D: exceeds supply");
            require(_owners[ids[i]] == address(0), "ERC1155D: supply exceeded");

            if (amounts[i] == 1) {
                _owners[ids[i]] = to;
            }
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _afterTokenTransfer(operator, address(0), to, ids, amounts, data);

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);
        uint256[] memory amounts = _asSingletonArray(amount);

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        require(_owners[id] == from && amount < 2, "ERC1155: burn amount exceeds balance");
        if (amount == 1) {
            _owners[id] = address(0);
        }

        emit TransferSingle(operator, from, address(0), id, amount);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), ids, amounts, "");

        for (uint256 i = 0; i < ids.length; i++) {
            uint256 id = ids[i];
            require(_owners[id] == from && amounts[i] < 2, "ERC1155: burn amount exceeds balance");
            if (amounts[i] == 1) {
                _owners[id] = address(0);
            }
        }

        emit TransferBatch(operator, from, address(0), ids, amounts);

        _afterTokenTransfer(operator, from, address(0), ids, amounts, "");
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _asSingletonArray(uint256 element) internal pure returns (uint256[] memory) {
        uint256[] memory array = new uint256[](1);
        array[0] = element;

        return array;
    }

    function _prepayGas(uint256 start, uint256 end) internal {
        require(end <= MAX_SUPPLY, "ERC1155D: end id exceeds maximum");

        for (uint256 i = start; i < end; i++) {

            bytes32 slotValue;
            assembly {
                slotValue := sload(add(_owners.slot, i))
            }

            bytes32 leftmostBitSetToOne = slotValue | bytes32(uint256(1) << 255);
            assembly {
                sstore(add(_owners.slot, i), leftmostBitSetToOne)
            }
        }
    }

    function getOwnershipRecordOffChain() external view returns(address[MAX_SUPPLY+1] memory) {
        return _owners;
    }

    function ownerOfERC721Like(uint256 id) external view returns(address) {
        require(id < _owners.length, "ERC1155D: id exceeds maximum");
        address owner = _owners[id];
        require(owner != address(0), "ERC1155D: owner query for nonexistent token");
        return owner;
    }

    function getERC721BalanceOffChain(address _address) external view returns(uint256) {
        uint256 counter = 0;
        for (uint256 i; i < _owners.length; i++) {
            if (_owners[i] == _address) {
                counter++;
            }
        }
        return counter;
    }
}
// File: contracts/Outlanders.sol

  pragma solidity >=0.8;

  interface IKeys {
    function balanceOf(address account, uint256 id) external returns (uint256);

    function safeTransferFrom(
      address from,
      address to,
      uint256 id,
      uint256 amount,
      bytes memory data
    ) external;
  }

  //AE THER
  pragma solidity >=0.8;





  contract Outlanders is ERC1155D, Ownable, ReentrancyGuard {
    using ECDSA for bytes32;
    using Strings for uint256;
    event Received(address, uint256);
    event claimNftWithKey(uint256 tokenId, uint256 keyId);
    event claimNftWithIndex(uint256 tokenId, uint256 Index);
    // Contract name
    string public name;
    // Contract symbol
    string public symbol;
    uint256 public count;
    string public baseUri;
    string public contractURI;
    string public extension;
    address public keyReceiver;
    address private _recipient;
    address signerAddress;
    uint256 royaltyPercentage;
    IKeys public immutable keys;

    constructor(
      string memory _Name,
      string memory _Symbol,
      string memory _contractURI,
      string memory _baseUri,
      address _signerAddress,
      address _keyReceiver,
      address Keys,
      uint256 _royaltyPercentage,
      string memory _extension
    ) ERC1155D(_contractURI) {
      name = _Name;
      symbol = _Symbol;
      signerAddress = _signerAddress;
      contractURI = _contractURI;
      baseUri = _baseUri;
      keyReceiver = _keyReceiver;
      keys = IKeys(Keys);
      _recipient = owner();
      royaltyPercentage = _royaltyPercentage;
      extension = _extension;
    }

    function validateUsingECDASignature(
      bytes calldata signature,
      uint256 tokenId,
      uint256 id
    ) public view {
      bytes32 hash = keccak256(
        abi.encodePacked(bytes32(uint256(uint160(msg.sender))), tokenId, id)
      );
      require(
        signerAddress == hash.toEthSignedMessageHash().recover(signature),
        "Signer address mismatch."
      );
    }

    function validateKeyOwnership(address sender, uint256 keyId) public {
      require(keys.balanceOf(sender, keyId) == 1, "user is not owner of nft_id");
    }

    function mintWithKey(
      bytes calldata signature,
      uint256 tokenId,
      uint256 keyId
    ) public payable nonReentrant {
      //can mint
      validateUsingECDASignature(signature, tokenId, keyId);
      //verify that owner of Keys nfts
      validateKeyOwnership(msg.sender, keyId);
      //transfering keys nft
      keys.safeTransferFrom(msg.sender, keyReceiver, keyId, 1, "");
      //minting
      _mintSingle(msg.sender, tokenId);
      //loggin tokenID and KeyId
      emit claimNftWithKey(tokenId, keyId);
    }

      function mintWithIndex(
      bytes calldata signature,
      uint256 tokenId,
      uint256 index
    ) public payable nonReentrant {
      //can mint
      validateUsingECDASignature(signature, tokenId, index);
      //minting
      _mintSingle(msg.sender, tokenId);
      //loggin tokenID and KeyId
      emit claimNftWithIndex(tokenId, index);
    }


    function burn(
      address from,
      uint256 id,
      uint256 amount
    ) public {
      _burn(from, id, amount);
    }

    function burnBatch(
      address from,
      uint256[] memory ids,
      uint256[] memory amounts
    ) public {
      _burnBatch(from, ids, amounts);
    }

    //Normal minting allows minting on public sale satisfyign the necessary conditions
    function airdrop(address reciever, uint256[] memory tokenIds)
      external
      onlyOwner
    {
      uint256 amount = tokenIds.length;
      require(amount >= 1, "nonzero airdrop");
      if (amount == 1) {
        _mintSingle(reciever, tokenIds[0]);
      } else {
        uint256[] memory values = new uint256[](amount);
        for (uint256 i = 0; i < amount; i++) {
          values[i] = 1;
        }
        _mintBatch(reciever, tokenIds, values, "");
      }
    }

    function uri(uint256 _tokenId) public view override returns (string memory) {
      require(_owners[_tokenId] != address(0), "tokenId does not exist");
      return
        bytes(baseUri).length > 0
          ? string(abi.encodePacked(baseUri, _tokenId.toString(), extension))
          : "";
    }

    function setExtension(string memory _extension) public onlyOwner nonReentrant{
      extension = _extension;
    }

    function setContractURI(string memory newContractURI)
      public
      onlyOwner
      nonReentrant
    {
      contractURI = newContractURI;
    }

    function setUri(string memory _uri) public onlyOwner nonReentrant {
      baseUri = _uri;
    }

    function setSignerAddress(address _signerAddress)
      public
      onlyOwner
      nonReentrant
    {
      signerAddress = _signerAddress;
    }

    function setKeyReceiver(address _newKeyReceiver)
      public
      onlyOwner
      nonReentrant
    {
      keyReceiver = _newKeyReceiver;
    }

    function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
      external
      view
      returns (address receiver, uint256 royaltyAmount)
    {
      return (_recipient, (_salePrice * royaltyPercentage) / 10000);
    }

    function setRoyalityPercentage(uint256 _royaltyPercentage) public onlyOwner nonReentrant{
      royaltyPercentage = _royaltyPercentage;
    }

    function supportsInterface(bytes4 interfaceId)
      public
      view
      virtual
      override(ERC1155D)
      returns (bool)
    {
      return (interfaceId == type(IERC2981).interfaceId ||
        super.supportsInterface(interfaceId));
    }

    function _setRoyalties(address newRecipient) internal {
      require(
        newRecipient != address(0),
        "Royalties: new recipient is the zero address"
      );
      _recipient = newRecipient;
    }

    function setRoyalties(address newRecipient) external onlyOwner nonReentrant {
      _setRoyalties(newRecipient);
    }
    // release address based on shares.
    function withdrawEth() external onlyOwner nonReentrant {
      (bool success, ) = msg.sender.call{value: address(this).balance}("");
      require(success, "Transfer failed.");
    }
    
    receive() external payable {
      emit Received(msg.sender, msg.value);
    }
  }

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_Name","type":"string"},{"internalType":"string","name":"_Symbol","type":"string"},{"internalType":"string","name":"_contractURI","type":"string"},{"internalType":"string","name":"_baseUri","type":"string"},{"internalType":"address","name":"_signerAddress","type":"address"},{"internalType":"address","name":"_keyReceiver","type":"address"},{"internalType":"address","name":"Keys","type":"address"},{"internalType":"uint256","name":"_royaltyPercentage","type":"uint256"},{"internalType":"string","name":"_extension","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","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":"","type":"address"},{"indexed":false,"internalType":"uint256","name":"","type":"uint256"}],"name":"Received","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"Index","type":"uint256"}],"name":"claimNftWithIndex","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"keyId","type":"uint256"}],"name":"claimNftWithKey","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"reciever","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"burnBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"count","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"extension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"getERC721BalanceOffChain","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwnershipRecordOffChain","outputs":[{"internalType":"address[10001]","name":"","type":"address[10001]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keyReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keys","outputs":[{"internalType":"contract IKeys","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"mintWithIndex","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"keyId","type":"uint256"}],"name":"mintWithKey","outputs":[],"stateMutability":"payable","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":"id","type":"uint256"}],"name":"ownerOfERC721Like","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","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":"newContractURI","type":"string"}],"name":"setContractURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_extension","type":"string"}],"name":"setExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newKeyReceiver","type":"address"}],"name":"setKeyReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_royaltyPercentage","type":"uint256"}],"name":"setRoyalityPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRecipient","type":"address"}],"name":"setRoyalties","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_signerAddress","type":"address"}],"name":"setSignerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setUri","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":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"keyId","type":"uint256"}],"name":"validateKeyOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"validateUsingECDASignature","outputs":[],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

0000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000016000000000000000000000000000000000000000000000000000000000000001a00000000000000000000000000000000000000000000000000000000000000220000000000000000000000000c4d12607206f2f1eea6f8e05241ed052f39a3691000000000000000000000000c4d12607206f2f1eea6f8e05241ed052f39a36910000000000000000000000002b5f2fc733acd1521a9efc6c4f354cdd7eec6c1b000000000000000000000000000000000000000000000000000000000000030900000000000000000000000000000000000000000000000000000000000002a00000000000000000000000000000000000000000000000000000000000000013526966746572733a204f75746c616e64657273000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011526966746572734f75746c616e646572730000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000042697066733a2f2f6261666b7265696372697034766f676f666d7763716a65657376616b7a346e6a3369673574766965366e733664726d6d6a737875327368327861710000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000043697066733a2f2f6261667962656968613475717237616b33637a366e6e776c76667a6e6236756765363637743566756c7861656f726536627974717a73696b7166342f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000052e6a736f6e000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _Name (string): Rifters: Outlanders
Arg [1] : _Symbol (string): RiftersOutlanders
Arg [2] : _contractURI (string): ipfs://bafkreicrip4vogofmwcqjeesvakz4nj3ig5tvie6ns6drmmjsxu2sh2xaq
Arg [3] : _baseUri (string): ipfs://bafybeiha4uqr7ak3cz6nnwlvfznb6uge667t5fulxaeore6bytqzsikqf4/
Arg [4] : _signerAddress (address): 0xC4D12607206F2f1eeA6f8E05241eD052F39A3691
Arg [5] : _keyReceiver (address): 0xC4D12607206F2f1eeA6f8E05241eD052F39A3691
Arg [6] : Keys (address): 0x2b5F2fc733Acd1521a9Efc6C4f354CDD7eEC6C1b
Arg [7] : _royaltyPercentage (uint256): 777
Arg [8] : _extension (string): .json

-----Encoded View---------------
23 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000160
Arg [2] : 00000000000000000000000000000000000000000000000000000000000001a0
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000220
Arg [4] : 000000000000000000000000c4d12607206f2f1eea6f8e05241ed052f39a3691
Arg [5] : 000000000000000000000000c4d12607206f2f1eea6f8e05241ed052f39a3691
Arg [6] : 0000000000000000000000002b5f2fc733acd1521a9efc6c4f354cdd7eec6c1b
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000309
Arg [8] : 00000000000000000000000000000000000000000000000000000000000002a0
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000013
Arg [10] : 526966746572733a204f75746c616e6465727300000000000000000000000000
Arg [11] : 0000000000000000000000000000000000000000000000000000000000000011
Arg [12] : 526966746572734f75746c616e64657273000000000000000000000000000000
Arg [13] : 0000000000000000000000000000000000000000000000000000000000000042
Arg [14] : 697066733a2f2f6261666b7265696372697034766f676f666d7763716a656573
Arg [15] : 76616b7a346e6a3369673574766965366e733664726d6d6a7378753273683278
Arg [16] : 6171000000000000000000000000000000000000000000000000000000000000
Arg [17] : 0000000000000000000000000000000000000000000000000000000000000043
Arg [18] : 697066733a2f2f6261667962656968613475717237616b33637a366e6e776c76
Arg [19] : 667a6e6236756765363637743566756c7861656f726536627974717a73696b71
Arg [20] : 66342f0000000000000000000000000000000000000000000000000000000000
Arg [21] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [22] : 2e6a736f6e000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

70616:6058:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76630:31;;;76639:10;188:51:1;;76651:9:0;270:2:1;255:18;;248:34;76630:31:0;;161:18:1;76630:31:0;;;;;;;70616:6058;;;;;52236:308;;;;;;;;;;-1:-1:-1;52236:308:0;;;;;:::i;:::-;;:::i;:::-;;;876:25:1;;;864:2;849:18;52236:308:0;;;;;;;;75737:257;;;;;;;;;;-1:-1:-1;75737:257:0;;;;;:::i;:::-;;:::i;:::-;;;1463:14:1;;1456:22;1438:41;;1426:2;1411:18;75737:257:0;1298:187:1;75031:153:0;;;;;;;;;;-1:-1:-1;75031:153:0;;;;;:::i;:::-;;:::i;:::-;;71002:20;;;;;;;;;;;;;;;;70926:18;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;74327:304::-;;;;;;;;;;-1:-1:-1;74327:304:0;;;;;:::i;:::-;;:::i;75351:227::-;;;;;;;;;;-1:-1:-1;75351:227:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;206:32:1;;;188:51;;270:2;255:18;;248:34;;;;161:18;75351:227:0;14:274:1;76225:120:0;;;;;;;;;;-1:-1:-1;76225:120:0;;;;;:::i;:::-;;:::i;71089:23::-;;;;;;;;;;;;;:::i;54252:442::-;;;;;;;;;;-1:-1:-1;54252:442:0;;;;;:::i;:::-;;:::i;71245:27::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;6002:32:1;;;5984:51;;5972:2;5957:18;71245:27:0;5824:217:1;50705:42:0;;;;;;;;;;;;50742:5;50705:42;;69933:295;;;;;;;;;;-1:-1:-1;69933:295:0;;;;;:::i;:::-;;:::i;71928:398::-;;;;;;;;;;-1:-1:-1;71928:398:0;;;;;:::i;:::-;;:::i;72501:547::-;;;;;;:::i;:::-;;:::i;52710:524::-;;;;;;;;;;-1:-1:-1;52710:524:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;69498:123::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;73571:163::-;;;;;;;;;;-1:-1:-1;73571:163:0;;;;;:::i;:::-;;:::i;29682:103::-;;;;;;;;;;;;;:::i;74639:116::-;;;;;;;;;;-1:-1:-1;74639:116:0;;;;;:::i;:::-;;:::i;75192:151::-;;;;;;;;;;-1:-1:-1;75192:151:0;;;;;:::i;:::-;;:::i;73830:489::-;;;;;;;;;;-1:-1:-1;73830:489:0;;;;;:::i;:::-;;:::i;75586:143::-;;;;;;;;;;-1:-1:-1;75586:143:0;;;;;:::i;:::-;;:::i;73058:364::-;;;;;;:::i;:::-;;:::i;29034:87::-;;;;;;;;;;-1:-1:-1;29107:6:0;;-1:-1:-1;;;;;29107:6:0;29034:87;;69629:296;;;;;;;;;;-1:-1:-1;69629:296:0;;;;;:::i;:::-;;:::i;74763:155::-;;;;;;;;;;-1:-1:-1;74763:155:0;;;;;:::i;:::-;;:::i;70975:20::-;;;;;;;;;;;;;:::i;71029:21::-;;;;;;;;;;;;;:::i;74926:97::-;;;;;;;;;;-1:-1:-1;74926:97:0;;;;;:::i;:::-;;:::i;72334:159::-;;;;;;;;;;-1:-1:-1;72334:159:0;;;;;:::i;:::-;;:::i;76392:185::-;;;;;;;;;;;;;:::i;53307:155::-;;;;;;;;;;-1:-1:-1;53307:155:0;;;;;:::i;:::-;;:::i;71119:26::-;;;;;;;;;;-1:-1:-1;71119:26:0;;;;-1:-1:-1;;;;;71119:26:0;;;71057:25;;;;;;;;;;;;;:::i;53534:168::-;;;;;;;;;;-1:-1:-1;53534:168:0;;;;;:::i;:::-;-1:-1:-1;;;;;53657:27:0;;;53633:4;53657:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;53534:168;53774:401;;;;;;;;;;-1:-1:-1;53774:401:0;;;;;:::i;:::-;;:::i;29940:201::-;;;;;;;;;;-1:-1:-1;29940:201:0;;;;;:::i;:::-;;:::i;73432:131::-;;;;;;;;;;-1:-1:-1;73432:131:0;;;;;:::i;:::-;;:::i;52236:308::-;52322:7;-1:-1:-1;;;;;52350:21:0;;52342:77;;;;-1:-1:-1;;;52342:77:0;;12763:2:1;52342:77:0;;;12745:21:1;12802:2;12782:18;;;12775:30;12841:34;12821:18;;;12814:62;-1:-1:-1;;;12892:18:1;;;12885:41;12943:19;;52342:77:0;;;;;;;;;50742:5;52438:2;:15;52430:56;;;;-1:-1:-1;;;52430:56:0;;13175:2:1;52430:56:0;;;13157:21:1;13214:2;13194:18;;;13187:30;13253;13233:18;;;13226:58;13301:18;;52430:56:0;12973:352:1;52430:56:0;52521:7;-1:-1:-1;;;;;52506:22:0;:7;52514:2;52506:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;52506:11:0;:22;:30;;52535:1;52506:30;;;52531:1;52506:30;52499:37;;;;52236:308;;;;;:::o;75737:257::-;75867:4;-1:-1:-1;;;;;;75895:41:0;;-1:-1:-1;;;75895:41:0;;:90;;;75949:36;75973:11;75949:23;:36::i;75031:153::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;75146:13:::2;:30:::0;;-1:-1:-1;;;;;;75146:30:0::2;-1:-1:-1::0;;;;;75146:30:0;::::2;;::::0;;-1:-1:-1;2909:7:0;:22;75031:153;:::o;2389:20::-:1;75031:153:::0;:::o;70926:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;74327:304::-;74388:13;74449:1;;74428:8;74420:17;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;74420:17:0;:31;74412:66;;;;-1:-1:-1;;;74412:66:0;;14049:2:1;74412:66:0;;;14031:21:1;14088:2;14068:18;;;14061:30;-1:-1:-1;;;14107:18:1;;;14100:52;14169:18;;74412:66:0;13847:346:1;74412:66:0;74527:1;74509:7;74503:21;;;;;:::i;:::-;;;:25;:120;;;;;;;;;;;;;;;;;74566:7;74575:19;:8;:17;:19::i;:::-;74596:9;74549:57;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;74487:136;74327:304;-1:-1:-1;;74327:304:0:o;75351:227::-;75517:10;;75543:17;;75454:16;;;;-1:-1:-1;;;;;75517:10:0;;;;75564:5;;75530:30;;:10;:30;:::i;:::-;75529:40;;;;:::i;:::-;75509:61;;;;75351:227;;;;;;:::o;76225:120::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;76310:27:::2;76324:12;76310:13;:27::i;:::-;2389:20:::1;1783:1:::0;2909:7;:22;2726:213;71089:23;;;;;;;:::i;54252:442::-;-1:-1:-1;;;;;54485:20:0;;27665:10;54485:20;;:60;;-1:-1:-1;54509:36:0;54526:4;27665:10;53534:168;:::i;54509:36::-;54463:160;;;;-1:-1:-1;;;54463:160:0;;16386:2:1;54463:160:0;;;16368:21:1;16425:2;16405:18;;;16398:30;16464:34;16444:18;;;16437:62;-1:-1:-1;;;16515:18:1;;;16508:48;16573:19;;54463:160:0;16184:414:1;54463:160:0;54634:52;54657:4;54663:2;54667:3;54672:7;54681:4;54634:22;:52::i;:::-;54252:442;;;;;:::o;69933:295::-;70007:7;;;70057:139;70077:14;70073:1;:18;70057:139;;;70131:8;-1:-1:-1;;;;;70117:22:0;:7;70125:1;70117:10;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;70117:10:0;:22;70113:72;;70160:9;;;;:::i;:::-;;;;70113:72;70093:3;;;;:::i;:::-;;;;70057:139;;;-1:-1:-1;70213:7:0;69933:295;-1:-1:-1;;69933:295:0:o;71928:398::-;72103:68;;;72144:10;72103:68;;;16928:19:1;16963:12;;;16956:28;;;17000:12;;;16993:28;;;72068:12:0;;17037::1;;72103:68:0;;;;;;;;;;;;72083:97;;;;;;72068:112;;72224:48;72262:9;;72224:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;72224:29:0;;-1:-1:-1;72224:4:0;;-1:-1:-1;72224:27:0;;-1:-1:-1;72224:29:0:i;:::-;:37;;:48::i;:::-;72207:13;;-1:-1:-1;;;;;72207:13:0;;;:65;;;72189:129;;;;-1:-1:-1;;;72189:129:0;;17262:2:1;72189:129:0;;;17244:21:1;17301:2;17281:18;;;17274:30;17340:26;17320:18;;;17313:54;17384:18;;72189:129:0;17060:348:1;72501:547:0;2345:21;:19;:21::i;:::-;72663:53:::1;72690:9;;72701:7;72710:5;72663:26;:53::i;:::-;72765:39;72786:10;72798:5;72765:20;:39::i;:::-;72877:11;::::0;72843:60:::1;::::0;-1:-1:-1;;;72843:60:0;;72865:10:::1;72843:60;::::0;::::1;17754:34:1::0;-1:-1:-1;;;;;72877:11:0;;::::1;17804:18:1::0;;;17797:43;17856:18;;;17849:34;;;72877:11:0;17899:18:1;;;17892:34;17734:3;17942:19;;;17935:32;-1:-1:-1;17983:19:1;;;17976:30;72843:4:0::1;:21:::0;;::::1;::::0;::::1;::::0;18023:19:1;;72843:60:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;72929:32;72941:10;72953:7;72929:11;:32::i;:::-;73009:31;::::0;;18227:25:1;;;18283:2;18268:18;;18261:34;;;73009:31:0::1;::::0;18200:18:1;73009:31:0::1;;;;;;;;2389:20:::0;1783:1;2909:7;:22;2726:213;2389:20;72501:547;;;;:::o;52710:524::-;52866:16;52927:3;:10;52908:8;:15;:29;52900:83;;;;-1:-1:-1;;;52900:83:0;;18508:2:1;52900:83:0;;;18490:21:1;18547:2;18527:18;;;18520:30;18586:34;18566:18;;;18559:62;-1:-1:-1;;;18637:18:1;;;18630:39;18686:19;;52900:83:0;18306:405:1;52900:83:0;52996:30;53043:8;:15;-1:-1:-1;;;;;53029:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;53029:30:0;;52996:63;;53077:9;53072:122;53096:8;:15;53092:1;:19;53072:122;;;53152:30;53162:8;53171:1;53162:11;;;;;;;;:::i;:::-;;;;;;;53175:3;53179:1;53175:6;;;;;;;;:::i;:::-;;;;;;;53152:9;:30::i;:::-;53133:13;53147:1;53133:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;53113:3;;;:::i;:::-;;;53072:122;;;-1:-1:-1;53213:13:0;52710:524;-1:-1:-1;;;52710:524:0:o;69498:123::-;69558:28;;:::i;:::-;69599:14;;;;;;;;;;;-1:-1:-1;;69599:14:0;;-1:-1:-1;69599:14:0;;;;-1:-1:-1;;;;;69599:14:0;;;;;;;;;;;;;;;;;;;;;;69498:123;:::o;73571:163::-;73696:30;73707:4;73713:3;73718:7;73696:10;:30::i;:::-;73571:163;;;:::o;29682:103::-;28920:13;:11;:13::i;:::-;29747:30:::1;29774:1;29747:18;:30::i;:::-;29682:103::o:0;74639:116::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;74725:9:::2;:22;74737:10:::0;74725:9;:22:::2;:::i;:::-;;2389:20:::1;1783:1:::0;2909:7;:22;2726:213;75192:151;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;75306:11:::2;:29:::0;;-1:-1:-1;;;;;;75306:29:0::2;-1:-1:-1::0;;;;;75306:29:0;::::2;;::::0;;-1:-1:-1;2909:7:0;:22;75031:153;:::o;73830:489::-;28920:13;:11;:13::i;:::-;73956:15;;73998:1:::1;73988:11:::0;::::1;;73980:39;;;::::0;-1:-1:-1;;;73980:39:0;;20996:2:1;73980:39:0::1;::::0;::::1;20978:21:1::0;21035:2;21015:18;;;21008:30;-1:-1:-1;;;21054:18:1;;;21047:45;21109:18;;73980:39:0::1;20794:339:1::0;73980:39:0::1;74032:6;74042:1;74032:11:::0;74028:284:::1;;74056:34;74068:8;74078;74087:1;74078:11;;;;;;;;:::i;:::-;;;;;;;74056;:34::i;74028:284::-;74117:23;74157:6;-1:-1:-1::0;;;;;74143:21:0::1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;74143:21:0::1;;74117:47;;74180:9;74175:75;74199:6;74195:1;:10;74175:75;;;74237:1;74225:6;74232:1;74225:9;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;:13;74207:3;::::1;::::0;::::1;:::i;:::-;;;;74175:75;;;;74260:42;74271:8;74281;74291:6;74260:42;;;;;;;;;;;::::0;:10:::1;:42::i;75586:143::-:0;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;75683:17:::2;:38:::0;;;2389:20:::1;1783:1:::0;2909:7;:22;2726:213;73058:364;2345:21;:19;:21::i;:::-;73222:53:::1;73249:9;;73260:7;73269:5;73222:26;:53::i;:::-;73301:32;73313:10;73325:7;73301:11;:32::i;:::-;73381:33;::::0;;18227:25:1;;;18283:2;18268:18;;18261:34;;;73381:33:0::1;::::0;18200:18:1;73381:33:0::1;18053:248:1::0;69629:296:0;69690:7;69723:14;69718:2;:19;69710:60;;;;-1:-1:-1;;;69710:60:0;;13175:2:1;69710:60:0;;;13157:21:1;13214:2;13194:18;;;13187:30;13253;13233:18;;;13226:58;13301:18;;69710:60:0;12973:352:1;69710:60:0;69781:13;69797:7;69805:2;69797:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;69797:11:0;;-1:-1:-1;69797:11:0;69819:75;;;;-1:-1:-1;;;69819:75:0;;21340:2:1;69819:75:0;;;21322:21:1;21379:2;21359:18;;;21352:30;21418:34;21398:18;;;21391:62;-1:-1:-1;;;21469:18:1;;;21462:41;21520:19;;69819:75:0;21138:407:1;74763:155:0;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;74882:11:::2;:28;74896:14:::0;74882:11;:28:::2;:::i;70975:20::-:0;;;;;;;:::i;71029:21::-;;;;;;;:::i;74926:97::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;75001:7:::2;:14;75011:4:::0;75001:7;:14:::2;:::i;72334:159::-:0;72419:29;;-1:-1:-1;;;72419:29:0;;-1:-1:-1;;;;;206:32:1;;;72419:29:0;;;188:51:1;255:18;;;248:34;;;72419:4:0;:14;;;;161:18:1;;72419:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72452:1;72419:34;72411:74;;;;-1:-1:-1;;;72411:74:0;;21941:2:1;72411:74:0;;;21923:21:1;21980:2;21960:18;;;21953:30;22019:29;21999:18;;;21992:57;22066:18;;72411:74:0;21739:351:1;72411:74:0;72334:159;;:::o;76392:185::-;28920:13;:11;:13::i;:::-;2345:21:::1;:19;:21::i;:::-;76475:49:::2;::::0;76457:12:::2;::::0;76475:10:::2;::::0;76498:21:::2;::::0;76457:12;76475:49;76457:12;76475:49;76498:21;76475:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;76456:68;;;76541:7;76533:36;;;::::0;-1:-1:-1;;;76533:36:0;;22507:2:1;76533:36:0::2;::::0;::::2;22489:21:1::0;22546:2;22526:18;;;22519:30;-1:-1:-1;;;22565:18:1;;;22558:46;22621:18;;76533:36:0::2;22305:340:1::0;76533:36:0::2;76447:130;2389:20:::1;1783:1:::0;2909:7;:22;2726:213;53307:155;53402:52;27665:10;53435:8;53445;53402:18;:52::i;71057:25::-;;;;;;;:::i;53774:401::-;-1:-1:-1;;;;;53982:20:0;;27665:10;53982:20;;:60;;-1:-1:-1;54006:36:0;54023:4;27665:10;53534:168;:::i;54006:36::-;53960:151;;;;-1:-1:-1;;;53960:151:0;;22852:2:1;53960:151:0;;;22834:21:1;22891:2;22871:18;;;22864:30;22930:34;22910:18;;;22903:62;-1:-1:-1;;;22981:18:1;;;22974:39;23030:19;;53960:151:0;22650:405:1;53960:151:0;54122:45;54140:4;54146:2;54150;54154:6;54162:4;54122:17;:45::i;29940:201::-;28920:13;:11;:13::i;:::-;-1:-1:-1;;;;;30029:22:0;::::1;30021:73;;;::::0;-1:-1:-1;;;30021:73:0;;23262:2:1;30021:73:0::1;::::0;::::1;23244:21:1::0;23301:2;23281:18;;;23274:30;23340:34;23320:18;;;23313:62;-1:-1:-1;;;23391:18:1;;;23384:36;23437:19;;30021:73:0::1;23060:402:1::0;30021:73:0::1;30105:28;30124:8;30105:18;:28::i;73432:131::-:0;73532:23;73538:4;73544:2;73548:6;73532:5;:23::i;51259:310::-;51361:4;-1:-1:-1;;;;;;51398:41:0;;-1:-1:-1;;;51398:41:0;;:110;;-1:-1:-1;;;;;;;51456:52:0;;-1:-1:-1;;;51456:52:0;51398:110;:163;;;-1:-1:-1;;;;;;;;;;42716:40:0;;;51525:36;42607:157;29199:132;29107:6;;-1:-1:-1;;;;;29107:6:0;27665:10;29263:23;29255:68;;;;-1:-1:-1;;;29255:68:0;;23669:2:1;29255:68:0;;;23651:21:1;;;23688:18;;;23681:30;23747:34;23727:18;;;23720:62;23799:18;;29255:68:0;23467:356:1;2425:293:0;1827:1;2559:7;;:19;2551:63;;;;-1:-1:-1;;;2551:63:0;;24030:2:1;2551:63:0;;;24012:21:1;24069:2;24049:18;;;24042:30;24108:33;24088:18;;;24081:61;24159:18;;2551:63:0;23828:355:1;2551:63:0;1827:1;2692:7;:18;2425:293::o;16251:716::-;16307:13;16358:14;16375:17;16386:5;16375:10;:17::i;:::-;16395:1;16375:21;16358:38;;16411:20;16445:6;-1:-1:-1;;;;;16434:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16434:18:0;-1:-1:-1;16411:41:0;-1:-1:-1;16576:28:0;;;16592:2;16576:28;16633:288;-1:-1:-1;;16665:5:0;-1:-1:-1;;;16802:2:0;16791:14;;16786:30;16665:5;16773:44;16863:2;16854:11;;;-1:-1:-1;16884:21:0;16633:288;16884:21;-1:-1:-1;16942:6:0;16251:716;-1:-1:-1;;;16251:716:0:o;76002:215::-;-1:-1:-1;;;;;76083:26:0;;76065:110;;;;-1:-1:-1;;;76065:110:0;;24390:2:1;76065:110:0;;;24372:21:1;24429:2;24409:18;;;24402:30;24468:34;24448:18;;;24441:62;-1:-1:-1;;;24519:18:1;;;24512:42;24571:19;;76065:110:0;24188:408:1;76065:110:0;76184:10;:25;;-1:-1:-1;;;;;;76184:25:0;-1:-1:-1;;;;;76184:25:0;;;;;;;;;;76002:215::o;56605:1009::-;56832:7;:14;56818:3;:10;:28;56810:81;;;;-1:-1:-1;;;56810:81:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56910:16:0;;56902:66;;;;-1:-1:-1;;;56902:66:0;;;;;;;:::i;:::-;27665:10;56981:16;57098:284;57122:3;:10;57118:1;:14;57098:284;;;57154:10;57167:3;57171:1;57167:6;;;;;;;;:::i;:::-;;;;;;;57154:19;;57213:4;-1:-1:-1;;;;;57198:19:0;:7;57206:2;57198:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;57198:11:0;:19;:37;;;;;57234:1;57221:7;57229:1;57221:10;;;;;;;;:::i;:::-;;;;;;;:14;57198:37;57190:92;;;;-1:-1:-1;;;57190:92:0;;;;;;;:::i;:::-;57303:7;57311:1;57303:10;;;;;;;;:::i;:::-;;;;;;;57317:1;57303:15;57299:72;;57353:2;57339:7;57347:2;57339:11;;;;;;;:::i;:::-;;:16;;-1:-1:-1;;;;;;57339:16:0;-1:-1:-1;;;;;57339:16:0;;;;;;;;;;57299:72;-1:-1:-1;57134:3:0;;;:::i;:::-;;;57098:284;;;;57429:2;-1:-1:-1;;;;;57399:47:0;57423:4;-1:-1:-1;;;;;57399:47:0;57413:8;-1:-1:-1;;;;;57399:47:0;;57433:3;57438:7;57399:47;;;;;;;:::i;:::-;;;;;;;;57531:75;57567:8;57577:4;57583:2;57587:3;57592:7;57601:4;57531:35;:75::i;:::-;56799:815;56605:1009;;;;;:::o;25591:269::-;25793:58;;26539:66:1;25793:58:0;;;26527:79:1;26622:12;;;26615:28;;;25660:7:0;;26659:12:1;;25793:58:0;;;;;;;;;;;;25783:69;;;;;;25776:76;;25591:269;;;:::o;21901:231::-;21979:7;22000:17;22019:18;22041:27;22052:4;22058:9;22041:10;:27::i;:::-;21999:69;;;;22079:18;22091:5;22079:11;:18::i;60420:488::-;-1:-1:-1;;;;;60501:16:0;;60493:62;;;;-1:-1:-1;;;60493:62:0;;;;;;;:::i;:::-;60650:1;;60635:2;60627:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;60627:11:0;:25;60619:63;;;;-1:-1:-1;;;60619:63:0;;27286:2:1;60619:63:0;;;27268:21:1;27325:2;27305:18;;;27298:30;-1:-1:-1;;;27344:18:1;;;27337:55;27409:18;;60619:63:0;27084:349:1;60619:63:0;60706:1;60701:2;:6;60693:41;;;;-1:-1:-1;;;60693:41:0;;27640:2:1;60693:41:0;;;27622:21:1;27679:2;27659:18;;;27652:30;-1:-1:-1;;;27698:18:1;;;27691:52;27760:18;;60693:41:0;27438:346:1;60693:41:0;60760:2;60746:7;60754:2;60746:11;;;;;;;:::i;:::-;;:16;;-1:-1:-1;;;;;;60746:16:0;-1:-1:-1;;;;;60746:16:0;;;;;;60859:41;;;18227:25:1;;;-1:-1:-1;18283:2:1;18268:18;;18261:34;60859:41:0;;;;-1:-1:-1;;60859:41:0;;;;18200:18:1;60859:41:0;;;;;;;60420:488;;:::o;63477:878::-;-1:-1:-1;;;;;63629:18:0;;63621:66;;;;-1:-1:-1;;;63621:66:0;;;;;;;:::i;:::-;63720:7;:14;63706:3;:10;:28;63698:81;;;;-1:-1:-1;;;63698:81:0;;;;;;;:::i;:::-;63836:66;;;;;;;;;63792:16;63836:66;;;;27665:10;;63915:282;63939:3;:10;63935:1;:14;63915:282;;;63971:10;63984:3;63988:1;63984:6;;;;;;;;:::i;:::-;;;;;;;63971:19;;64028:4;-1:-1:-1;;;;;64013:19:0;:7;64021:2;64013:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;64013:11:0;:19;:37;;;;;64049:1;64036:7;64044:1;64036:10;;;;;;;;:::i;:::-;;;;;;;:14;64013:37;64005:86;;;;-1:-1:-1;;;64005:86:0;;;;;;;:::i;:::-;64110:7;64118:1;64110:10;;;;;;;;:::i;:::-;;;;;;;64124:1;64110:15;64106:80;;64168:1;64146:7;64154:2;64146:11;;;;;;;:::i;:::-;;:24;;-1:-1:-1;;;;;;64146:24:0;-1:-1:-1;;;;;64146:24:0;;;;;;;;;;64106:80;-1:-1:-1;63951:3:0;;;;:::i;:::-;;;;63915:282;;;;64252:1;-1:-1:-1;;;;;64214:55:0;64238:4;-1:-1:-1;;;;;64214:55:0;64228:8;-1:-1:-1;;;;;64214:55:0;;64256:3;64261:7;64214:55;;;;;;;:::i;:::-;;;;;;;;64282:65;;;;;;;;;64326:1;64282:65;;;56605:1009;30301:191;30394:6;;;-1:-1:-1;;;;;30411:17:0;;;-1:-1:-1;;;;;;30411:17:0;;;;;;;30444:40;;30394:6;;;30411:17;30394:6;;30444:40;;30375:16;;30444:40;30364:128;30301:191;:::o;61264:1003::-;-1:-1:-1;;;;;61442:16:0;;61434:62;;;;-1:-1:-1;;;61434:62:0;;;;;;;:::i;:::-;61529:7;:14;61515:3;:10;:28;61507:81;;;;-1:-1:-1;;;61507:81:0;;;;;;;:::i;:::-;27665:10;61601:16;61724:293;61748:3;:10;61744:1;:14;61724:293;;;61801:1;61788:7;61796:1;61788:10;;;;;;;;:::i;:::-;;;;;;;:14;61780:51;;;;-1:-1:-1;;;61780:51:0;;29061:2:1;61780:51:0;;;29043:21:1;29100:2;29080:18;;;29073:30;29139:26;29119:18;;;29112:54;29183:18;;61780:51:0;28859:348:1;61780:51:0;61881:1;-1:-1:-1;;;;;61854:29:0;:7;61862:3;61866:1;61862:6;;;;;;;;:::i;:::-;;;;;;;61854:15;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;61854:15:0;:29;61846:67;;;;-1:-1:-1;;;61846:67:0;;27286:2:1;61846:67:0;;;27268:21:1;27325:2;27305:18;;;27298:30;-1:-1:-1;;;27344:18:1;;;27337:55;27409:18;;61846:67:0;27084:349:1;61846:67:0;61934:7;61942:1;61934:10;;;;;;;;:::i;:::-;;;;;;;61948:1;61934:15;61930:76;;61988:2;61970:7;61978:3;61982:1;61978:6;;;;;;;;:::i;:::-;;;;;;;61970:15;;;;;;;:::i;:::-;;:20;;-1:-1:-1;;;;;;61970:20:0;-1:-1:-1;;;;;61970:20:0;;;;;;;;;;61930:76;61760:3;;;;:::i;:::-;;;;61724:293;;;;62070:2;-1:-1:-1;;;;;62034:53:0;62066:1;-1:-1:-1;;;;;62034:53:0;62048:8;-1:-1:-1;;;;;62034:53:0;;62074:3;62079:7;62034:53;;;;;;;:::i;:::-;;;;;;;;62178:81;62214:8;62232:1;62236:2;62240:3;62245:7;62254:4;62178:35;:81::i;64497:331::-;64652:8;-1:-1:-1;;;;;64643:17:0;:5;-1:-1:-1;;;;;64643:17:0;;64635:71;;;;-1:-1:-1;;;64635:71:0;;29414:2:1;64635:71:0;;;29396:21:1;29453:2;29433:18;;;29426:30;29492:34;29472:18;;;29465:62;-1:-1:-1;;;29543:18:1;;;29536:39;29592:19;;64635:71:0;29212:405:1;64635:71:0;-1:-1:-1;;;;;64717:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;64717:46:0;;;;;;;;;;64779:41;;1438::1;;;64779::0;;1411:18:1;64779:41:0;;;;;;;64497:331;;;:::o;55158:1089::-;-1:-1:-1;;;;;55346:16:0;;55338:66;;;;-1:-1:-1;;;55338:66:0;;;;;;;:::i;:::-;27665:10;55417:16;55482:21;55500:2;55482:17;:21::i;:::-;55459:44;;55514:24;55541:25;55559:6;55541:17;:25::i;:::-;55514:52;;55675:4;-1:-1:-1;;;;;55660:19:0;:7;55668:2;55660:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;55660:11:0;:19;:33;;;;;55692:1;55683:6;:10;55660:33;55652:88;;;;-1:-1:-1;;;55652:88:0;;;;;;;:::i;:::-;55967:6;55977:1;55967:11;55963:60;;56009:2;55995:7;56003:2;55995:11;;;;;;;:::i;:::-;;:16;;-1:-1:-1;;;;;;55995:16:0;-1:-1:-1;;;;;55995:16:0;;;;;;;;;;55963:60;56071:2;-1:-1:-1;;;;;56040:46:0;56065:4;-1:-1:-1;;;;;56040:46:0;56055:8;-1:-1:-1;;;;;56040:46:0;;56075:2;56079:6;56040:46;;;;;;18227:25:1;;;18283:2;18268:18;;18261:34;18215:2;18200:18;;18053:248;56040:46:0;;;;;;;;56171:68;56202:8;56212:4;56218:2;56222;56226:6;56234:4;56171:30;:68::i;:::-;55327:920;;;55158:1089;;;;;:::o;62517:757::-;-1:-1:-1;;;;;62644:18:0;;62636:66;;;;-1:-1:-1;;;62636:66:0;;;;;;;:::i;:::-;27665:10;62715:16;62780:21;62798:2;62780:17;:21::i;:::-;62757:44;;62812:24;62839:25;62857:6;62839:17;:25::i;:::-;62877:66;;;;;;;;;62922:1;62877:66;;62812:52;-1:-1:-1;62979:4:0;-1:-1:-1;;;;;62964:19:0;:7;62972:2;62964:11;;;;;;;:::i;:::-;;;-1:-1:-1;;;;;62964:11:0;:19;:33;;;;;62996:1;62987:6;:10;62964:33;62956:82;;;;-1:-1:-1;;;62956:82:0;;;;;;;:::i;:::-;63053:6;63063:1;63053:11;63049:68;;63103:1;63081:7;63089:2;63081:11;;;;;;;:::i;:::-;;:24;;-1:-1:-1;;;;;;63081:24:0;-1:-1:-1;;;;;63081:24:0;;;;;;;;;;63049:68;63134:54;;;18227:25:1;;;18283:2;18268:18;;18261:34;;;63173:1:0;;-1:-1:-1;;;;;63134:54:0;;;;;;;;;;18200:18:1;63134:54:0;;;;;;;63201:65;;;;;;;;;63245:1;63201:65;;;56605:1009;13117:922;13170:7;;-1:-1:-1;;;13248:15:0;;13244:102;;-1:-1:-1;;;13284:15:0;;;-1:-1:-1;13328:2:0;13318:12;13244:102;13373:6;13364:5;:15;13360:102;;13409:6;13400:15;;;-1:-1:-1;13444:2:0;13434:12;13360:102;13489:6;13480:5;:15;13476:102;;13525:6;13516:15;;;-1:-1:-1;13560:2:0;13550:12;13476:102;13605:5;13596;:14;13592:99;;13640:5;13631:14;;;-1:-1:-1;13674:1:0;13664:11;13592:99;13718:5;13709;:14;13705:99;;13753:5;13744:14;;;-1:-1:-1;13787:1:0;13777:11;13705:99;13831:5;13822;:14;13818:99;;13866:5;13857:14;;;-1:-1:-1;13900:1:0;13890:11;13818:99;13944:5;13935;:14;13931:66;;13980:1;13970:11;14025:6;13117:922;-1:-1:-1;;13117:922:0:o;67940:813::-;-1:-1:-1;;;;;68180:13:0;;32027:19;:23;68176:570;;68216:79;;-1:-1:-1;;;68216:79:0;;-1:-1:-1;;;;;68216:43:0;;;;;:79;;68260:8;;68270:4;;68276:3;;68281:7;;68290:4;;68216:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68216:79:0;;;;;;;;-1:-1:-1;;68216:79:0;;;;;;;;;;;;:::i;:::-;;;68212:523;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;68608:6;68601:14;;-1:-1:-1;;;68601:14:0;;;;;;;;:::i;68212:523::-;;;68657:62;;-1:-1:-1;;;68657:62:0;;31770:2:1;68657:62:0;;;31752:21:1;31809:2;31789:18;;;31782:30;31848:34;31828:18;;;31821:62;-1:-1:-1;;;31899:18:1;;;31892:50;31959:19;;68657:62:0;31568:416:1;68212:523:0;-1:-1:-1;;;;;;68377:60:0;;-1:-1:-1;;;68377:60:0;68373:159;;68462:50;;-1:-1:-1;;;68462:50:0;;;;;;;:::i;68373:159::-;68296:251;67940:813;;;;;;:::o;20352:747::-;20433:7;20442:12;20471:9;:16;20491:2;20471:22;20467:625;;20815:4;20800:20;;20794:27;20865:4;20850:20;;20844:27;20923:4;20908:20;;20902:27;20510:9;20894:36;20966:25;20977:4;20894:36;20794:27;20844;20966:10;:25::i;:::-;20959:32;;;;;;;;;20467:625;-1:-1:-1;21040:1:0;;-1:-1:-1;21044:35:0;21024:56;;18745:521;18823:20;18814:5;:29;;;;;;;;:::i;:::-;;18810:449;;18745:521;:::o;18810:449::-;18921:29;18912:5;:38;;;;;;;;:::i;:::-;;18908:351;;18967:34;;-1:-1:-1;;;18967:34:0;;32732:2:1;18967:34:0;;;32714:21:1;32771:2;32751:18;;;32744:30;32810:26;32790:18;;;32783:54;32854:18;;18967:34:0;32530:348:1;18908:351:0;19032:35;19023:5;:44;;;;;;;;:::i;:::-;;19019:240;;19084:41;;-1:-1:-1;;;19084:41:0;;33085:2:1;19084:41:0;;;33067:21:1;33124:2;33104:18;;;33097:30;33163:33;33143:18;;;33136:61;33214:18;;19084:41:0;32883:355:1;19019:240:0;19156:30;19147:5;:39;;;;;;;;:::i;:::-;;19143:116;;19203:44;;-1:-1:-1;;;19203:44:0;;33445:2:1;19203:44:0;;;33427:21:1;33484:2;33464:18;;;33457:30;33523:34;33503:18;;;33496:62;-1:-1:-1;;;33574:18:1;;;33567:32;33616:19;;19203:44:0;33243:398:1;68761:199:0;68882:16;;;68896:1;68882:16;;;;;;;;;68828;;68857:22;;68882:16;;;;;;;;;;;;-1:-1:-1;68882:16:0;68857:41;;68920:7;68909:5;68915:1;68909:8;;;;;;;;:::i;:::-;;;;;;;;;;:18;68947:5;68761:199;-1:-1:-1;;68761:199:0:o;67188:744::-;-1:-1:-1;;;;;67403:13:0;;32027:19;:23;67399:526;;67439:72;;-1:-1:-1;;;67439:72:0;;-1:-1:-1;;;;;67439:38:0;;;;;:72;;67478:8;;67488:4;;67494:2;;67498:6;;67506:4;;67439:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67439:72:0;;;;;;;;-1:-1:-1;;67439:72:0;;;;;;;;;;;;:::i;:::-;;;67435:479;;;;:::i;:::-;-1:-1:-1;;;;;;67561:55:0;;-1:-1:-1;;;67561:55:0;67557:154;;67641:50;;-1:-1:-1;;;67641:50:0;;;;;;;:::i;23353:1520::-;23484:7;;24418:66;24405:79;;24401:163;;;-1:-1:-1;24517:1:0;;-1:-1:-1;24521:30:0;24501:51;;24401:163;24678:24;;;24661:14;24678:24;;;;;;;;;34439:25:1;;;34512:4;34500:17;;34480:18;;;34473:45;;;;34534:18;;;34527:34;;;34577:18;;;34570:34;;;24678:24:0;;34411:19:1;;24678:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;24678:24:0;;-1:-1:-1;;24678:24:0;;;-1:-1:-1;;;;;;;24717:20:0;;24713:103;;24770:1;24774:29;24754:50;;;;;;;24713:103;24836:6;-1:-1:-1;24844:20:0;;-1:-1:-1;23353:1520:0;;;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;293:173:1:-;361:20;;-1:-1:-1;;;;;410:31:1;;400:42;;390:70;;456:1;453;446:12;390:70;293:173;;;:::o;471:254::-;539:6;547;600:2;588:9;579:7;575:23;571:32;568:52;;;616:1;613;606:12;568:52;639:29;658:9;639:29;:::i;:::-;629:39;715:2;700:18;;;;687:32;;-1:-1:-1;;;471:254:1:o;912:131::-;-1:-1:-1;;;;;;986:32:1;;976:43;;966:71;;1033:1;1030;1023:12;1048:245;1106:6;1159:2;1147:9;1138:7;1134:23;1130:32;1127:52;;;1175:1;1172;1165:12;1127:52;1214:9;1201:23;1233:30;1257:5;1233:30;:::i;:::-;1282:5;1048:245;-1:-1:-1;;;1048:245:1:o;1490:186::-;1549:6;1602:2;1590:9;1581:7;1577:23;1573:32;1570:52;;;1618:1;1615;1608:12;1570:52;1641:29;1660:9;1641:29;:::i;1681:250::-;1766:1;1776:113;1790:6;1787:1;1784:13;1776:113;;;1866:11;;;1860:18;1847:11;;;1840:39;1812:2;1805:10;1776:113;;;-1:-1:-1;;1923:1:1;1905:16;;1898:27;1681:250::o;1936:271::-;1978:3;2016:5;2010:12;2043:6;2038:3;2031:19;2059:76;2128:6;2121:4;2116:3;2112:14;2105:4;2098:5;2094:16;2059:76;:::i;:::-;2189:2;2168:15;-1:-1:-1;;2164:29:1;2155:39;;;;2196:4;2151:50;;1936:271;-1:-1:-1;;1936:271:1:o;2212:220::-;2361:2;2350:9;2343:21;2324:4;2381:45;2422:2;2411:9;2407:18;2399:6;2381:45;:::i;2437:180::-;2496:6;2549:2;2537:9;2528:7;2524:23;2520:32;2517:52;;;2565:1;2562;2555:12;2517:52;-1:-1:-1;2588:23:1;;2437:180;-1:-1:-1;2437:180:1:o;2622:248::-;2690:6;2698;2751:2;2739:9;2730:7;2726:23;2722:32;2719:52;;;2767:1;2764;2757:12;2719:52;-1:-1:-1;;2790:23:1;;;2860:2;2845:18;;;2832:32;;-1:-1:-1;2622:248:1:o;2875:127::-;2936:10;2931:3;2927:20;2924:1;2917:31;2967:4;2964:1;2957:15;2991:4;2988:1;2981:15;3007:249;3117:2;3098:13;;-1:-1:-1;;3094:27:1;3082:40;;-1:-1:-1;;;;;3137:34:1;;3173:22;;;3134:62;3131:88;;;3199:18;;:::i;:::-;3235:2;3228:22;-1:-1:-1;;3007:249:1:o;3261:183::-;3321:4;-1:-1:-1;;;;;3346:6:1;3343:30;3340:56;;;3376:18;;:::i;:::-;-1:-1:-1;3421:1:1;3417:14;3433:4;3413:25;;3261:183::o;3449:724::-;3503:5;3556:3;3549:4;3541:6;3537:17;3533:27;3523:55;;3574:1;3571;3564:12;3523:55;3610:6;3597:20;3636:4;3659:43;3699:2;3659:43;:::i;:::-;3731:2;3725:9;3743:31;3771:2;3763:6;3743:31;:::i;:::-;3809:18;;;3901:1;3897:10;;;;3885:23;;3881:32;;;3843:15;;;;-1:-1:-1;3925:15:1;;;3922:35;;;3953:1;3950;3943:12;3922:35;3989:2;3981:6;3977:15;4001:142;4017:6;4012:3;4009:15;4001:142;;;4083:17;;4071:30;;4121:12;;;;4034;;4001:142;;;-1:-1:-1;4161:6:1;3449:724;-1:-1:-1;;;;;;3449:724:1:o;4178:468::-;4242:5;-1:-1:-1;;;;;4268:6:1;4265:30;4262:56;;;4298:18;;:::i;:::-;4347:2;4341:9;4359:69;4416:2;4395:15;;-1:-1:-1;;4391:29:1;4422:4;4387:40;4341:9;4359:69;:::i;:::-;4446:6;4437:15;;4476:6;4468;4461:22;4516:3;4507:6;4502:3;4498:16;4495:25;4492:45;;;4533:1;4530;4523:12;4492:45;4583:6;4578:3;4571:4;4563:6;4559:17;4546:44;4638:1;4631:4;4622:6;4614;4610:19;4606:30;4599:41;;4178:468;;;;;:::o;4651:220::-;4693:5;4746:3;4739:4;4731:6;4727:17;4723:27;4713:55;;4764:1;4761;4754:12;4713:55;4786:79;4861:3;4852:6;4839:20;4832:4;4824:6;4820:17;4786:79;:::i;4876:943::-;5030:6;5038;5046;5054;5062;5115:3;5103:9;5094:7;5090:23;5086:33;5083:53;;;5132:1;5129;5122:12;5083:53;5155:29;5174:9;5155:29;:::i;:::-;5145:39;;5203:38;5237:2;5226:9;5222:18;5203:38;:::i;:::-;5193:48;;5292:2;5281:9;5277:18;5264:32;-1:-1:-1;;;;;5356:2:1;5348:6;5345:14;5342:34;;;5372:1;5369;5362:12;5342:34;5395:61;5448:7;5439:6;5428:9;5424:22;5395:61;:::i;:::-;5385:71;;5509:2;5498:9;5494:18;5481:32;5465:48;;5538:2;5528:8;5525:16;5522:36;;;5554:1;5551;5544:12;5522:36;5577:63;5632:7;5621:8;5610:9;5606:24;5577:63;:::i;:::-;5567:73;;5693:3;5682:9;5678:19;5665:33;5649:49;;5723:2;5713:8;5710:16;5707:36;;;5739:1;5736;5729:12;5707:36;;5762:51;5805:7;5794:8;5783:9;5779:24;5762:51;:::i;:::-;5752:61;;;4876:943;;;;;;;;:::o;6046:733::-;6134:6;6142;6150;6158;6211:2;6199:9;6190:7;6186:23;6182:32;6179:52;;;6227:1;6224;6217:12;6179:52;6267:9;6254:23;-1:-1:-1;;;;;6337:2:1;6329:6;6326:14;6323:34;;;6353:1;6350;6343:12;6323:34;6391:6;6380:9;6376:22;6366:32;;6436:7;6429:4;6425:2;6421:13;6417:27;6407:55;;6458:1;6455;6448:12;6407:55;6498:2;6485:16;6524:2;6516:6;6513:14;6510:34;;;6540:1;6537;6530:12;6510:34;6587:7;6580:4;6571:6;6567:2;6563:15;6559:26;6556:39;6553:59;;;6608:1;6605;6598:12;6553:59;6639:4;6631:13;;;;6663:6;;-1:-1:-1;6701:20:1;;;6688:34;;6769:2;6754:18;6741:32;;-1:-1:-1;6046:733:1;;-1:-1:-1;;;;6046:733:1:o;6784:1208::-;6902:6;6910;6963:2;6951:9;6942:7;6938:23;6934:32;6931:52;;;6979:1;6976;6969:12;6931:52;7019:9;7006:23;-1:-1:-1;;;;;7089:2:1;7081:6;7078:14;7075:34;;;7105:1;7102;7095:12;7075:34;7143:6;7132:9;7128:22;7118:32;;7188:7;7181:4;7177:2;7173:13;7169:27;7159:55;;7210:1;7207;7200:12;7159:55;7246:2;7233:16;7268:4;7291:43;7331:2;7291:43;:::i;:::-;7363:2;7357:9;7375:31;7403:2;7395:6;7375:31;:::i;:::-;7441:18;;;7529:1;7525:10;;;;7517:19;;7513:28;;;7475:15;;;;-1:-1:-1;7553:19:1;;;7550:39;;;7585:1;7582;7575:12;7550:39;7609:11;;;;7629:148;7645:6;7640:3;7637:15;7629:148;;;7711:23;7730:3;7711:23;:::i;:::-;7699:36;;7662:12;;;;7755;;;;7629:148;;;7796:6;-1:-1:-1;;7840:18:1;;7827:32;;-1:-1:-1;;7871:16:1;;;7868:36;;;7900:1;7897;7890:12;7868:36;;7923:63;7978:7;7967:8;7956:9;7952:24;7923:63;:::i;:::-;7913:73;;;6784:1208;;;;;:::o;7997:435::-;8050:3;8088:5;8082:12;8115:6;8110:3;8103:19;8141:4;8170:2;8165:3;8161:12;8154:19;;8207:2;8200:5;8196:14;8228:1;8238:169;8252:6;8249:1;8246:13;8238:169;;;8313:13;;8301:26;;8347:12;;;;8382:15;;;;8274:1;8267:9;8238:169;;;-1:-1:-1;8423:3:1;;7997:435;-1:-1:-1;;;;;7997:435:1:o;8437:261::-;8616:2;8605:9;8598:21;8579:4;8636:56;8688:2;8677:9;8673:18;8665:6;8636:56;:::i;8703:534::-;8891:6;8876:22;;8880:9;8975:6;8849:4;9009:222;9023:6;9020:1;9017:13;9009:222;;;9088:13;;-1:-1:-1;;;;;9084:39:1;9072:52;;9147:4;9171:12;;;;9206:15;;;;9120:1;9038:9;9009:222;;;9013:3;;;8703:534;;;;:::o;9242:669::-;9369:6;9377;9385;9438:2;9426:9;9417:7;9413:23;9409:32;9406:52;;;9454:1;9451;9444:12;9406:52;9477:29;9496:9;9477:29;:::i;:::-;9467:39;;9557:2;9546:9;9542:18;9529:32;-1:-1:-1;;;;;9621:2:1;9613:6;9610:14;9607:34;;;9637:1;9634;9627:12;9607:34;9660:61;9713:7;9704:6;9693:9;9689:22;9660:61;:::i;:::-;9650:71;;9774:2;9763:9;9759:18;9746:32;9730:48;;9803:2;9793:8;9790:16;9787:36;;;9819:1;9816;9809:12;9787:36;;9842:63;9897:7;9886:8;9875:9;9871:24;9842:63;:::i;:::-;9832:73;;;9242:669;;;;;:::o;9916:450::-;9985:6;10038:2;10026:9;10017:7;10013:23;10009:32;10006:52;;;10054:1;10051;10044:12;10006:52;10094:9;10081:23;-1:-1:-1;;;;;10119:6:1;10116:30;10113:50;;;10159:1;10156;10149:12;10113:50;10182:22;;10235:4;10227:13;;10223:27;-1:-1:-1;10213:55:1;;10264:1;10261;10254:12;10213:55;10287:73;10352:7;10347:2;10334:16;10329:2;10325;10321:11;10287:73;:::i;:::-;10277:83;9916:450;-1:-1:-1;;;;9916:450:1:o;10371:422::-;10464:6;10472;10525:2;10513:9;10504:7;10500:23;10496:32;10493:52;;;10541:1;10538;10531:12;10493:52;10564:29;10583:9;10564:29;:::i;:::-;10554:39;;10644:2;10633:9;10629:18;10616:32;-1:-1:-1;;;;;10663:6:1;10660:30;10657:50;;;10703:1;10700;10693:12;10657:50;10726:61;10779:7;10770:6;10759:9;10755:22;10726:61;:::i;11006:347::-;11071:6;11079;11132:2;11120:9;11111:7;11107:23;11103:32;11100:52;;;11148:1;11145;11138:12;11100:52;11171:29;11190:9;11171:29;:::i;:::-;11161:39;;11250:2;11239:9;11235:18;11222:32;11297:5;11290:13;11283:21;11276:5;11273:32;11263:60;;11319:1;11316;11309:12;11263:60;11342:5;11332:15;;;11006:347;;;;;:::o;11358:260::-;11426:6;11434;11487:2;11475:9;11466:7;11462:23;11458:32;11455:52;;;11503:1;11500;11493:12;11455:52;11526:29;11545:9;11526:29;:::i;:::-;11516:39;;11574:38;11608:2;11597:9;11593:18;11574:38;:::i;:::-;11564:48;;11358:260;;;;;:::o;11623:606::-;11727:6;11735;11743;11751;11759;11812:3;11800:9;11791:7;11787:23;11783:33;11780:53;;;11829:1;11826;11819:12;11780:53;11852:29;11871:9;11852:29;:::i;:::-;11842:39;;11900:38;11934:2;11923:9;11919:18;11900:38;:::i;:::-;11890:48;;11985:2;11974:9;11970:18;11957:32;11947:42;;12036:2;12025:9;12021:18;12008:32;11998:42;;12091:3;12080:9;12076:19;12063:33;-1:-1:-1;;;;;12111:6:1;12108:30;12105:50;;;12151:1;12148;12141:12;12105:50;12174:49;12215:7;12206:6;12195:9;12191:22;12174:49;:::i;12234:322::-;12311:6;12319;12327;12380:2;12368:9;12359:7;12355:23;12351:32;12348:52;;;12396:1;12393;12386:12;12348:52;12419:29;12438:9;12419:29;:::i;:::-;12409:39;12495:2;12480:18;;12467:32;;-1:-1:-1;12546:2:1;12531:18;;;12518:32;;12234:322;-1:-1:-1;;;12234:322:1:o;13330:127::-;13391:10;13386:3;13382:20;13379:1;13372:31;13422:4;13419:1;13412:15;13446:4;13443:1;13436:15;13462:380;13541:1;13537:12;;;;13584;;;13605:61;;13659:4;13651:6;13647:17;13637:27;;13605:61;13712:2;13704:6;13701:14;13681:18;13678:38;13675:161;;13758:10;13753:3;13749:20;13746:1;13739:31;13793:4;13790:1;13783:15;13821:4;13818:1;13811:15;13675:161;;13462:380;;;:::o;14324:722::-;14374:3;14415:5;14409:12;14444:36;14470:9;14444:36;:::i;:::-;14499:1;14516:18;;;14543:133;;;;14690:1;14685:355;;;;14509:531;;14543:133;-1:-1:-1;;14576:24:1;;14564:37;;14649:14;;14642:22;14630:35;;14621:45;;;-1:-1:-1;14543:133:1;;14685:355;14716:5;14713:1;14706:16;14745:4;14790:2;14787:1;14777:16;14815:1;14829:165;14843:6;14840:1;14837:13;14829:165;;;14921:14;;14908:11;;;14901:35;14964:16;;;;14858:10;;14829:165;;;14833:3;;;15023:6;15018:3;15014:16;15007:23;;14509:531;;;;;14324:722;;;;:::o;15051:469::-;15272:3;15300:38;15334:3;15326:6;15300:38;:::i;:::-;15367:6;15361:13;15383:65;15441:6;15437:2;15430:4;15422:6;15418:17;15383:65;:::i;:::-;15464:50;15506:6;15502:2;15498:15;15490:6;15464:50;:::i;:::-;15457:57;15051:469;-1:-1:-1;;;;;;;15051:469:1:o;15525:127::-;15586:10;15581:3;15577:20;15574:1;15567:31;15617:4;15614:1;15607:15;15641:4;15638:1;15631:15;15657:168;15730:9;;;15761;;15778:15;;;15772:22;;15758:37;15748:71;;15799:18;;:::i;15962:217::-;16002:1;16028;16018:132;;16072:10;16067:3;16063:20;16060:1;16053:31;16107:4;16104:1;16097:15;16135:4;16132:1;16125:15;16018:132;-1:-1:-1;16164:9:1;;15962:217::o;16603:135::-;16642:3;16663:17;;;16660:43;;16683:18;;:::i;:::-;-1:-1:-1;16730:1:1;16719:13;;16603:135::o;18716:545::-;18818:2;18813:3;18810:11;18807:448;;;18854:1;18879:5;18875:2;18868:17;18924:4;18920:2;18910:19;18994:2;18982:10;18978:19;18975:1;18971:27;18965:4;18961:38;19030:4;19018:10;19015:20;19012:47;;;-1:-1:-1;19053:4:1;19012:47;19108:2;19103:3;19099:12;19096:1;19092:20;19086:4;19082:31;19072:41;;19163:82;19181:2;19174:5;19171:13;19163:82;;;19226:17;;;19207:1;19196:13;19163:82;;19437:1352;19563:3;19557:10;-1:-1:-1;;;;;19582:6:1;19579:30;19576:56;;;19612:18;;:::i;:::-;19641:97;19731:6;19691:38;19723:4;19717:11;19691:38;:::i;:::-;19685:4;19641:97;:::i;:::-;19793:4;;19857:2;19846:14;;19874:1;19869:663;;;;20576:1;20593:6;20590:89;;;-1:-1:-1;20645:19:1;;;20639:26;20590:89;-1:-1:-1;;19394:1:1;19390:11;;;19386:24;19382:29;19372:40;19418:1;19414:11;;;19369:57;20692:81;;19839:944;;19869:663;14271:1;14264:14;;;14308:4;14295:18;;-1:-1:-1;;19905:20:1;;;20023:236;20037:7;20034:1;20031:14;20023:236;;;20126:19;;;20120:26;20105:42;;20218:27;;;;20186:1;20174:14;;;;20053:19;;20023:236;;;20027:3;20287:6;20278:7;20275:19;20272:201;;;20348:19;;;20342:26;-1:-1:-1;;20431:1:1;20427:14;;;20443:3;20423:24;20419:37;20415:42;20400:58;20385:74;;20272:201;-1:-1:-1;;;;;20519:1:1;20503:14;;;20499:22;20486:36;;-1:-1:-1;19437:1352:1:o;21550:184::-;21620:6;21673:2;21661:9;21652:7;21648:23;21644:32;21641:52;;;21689:1;21686;21679:12;21641:52;-1:-1:-1;21712:16:1;;21550:184;-1:-1:-1;21550:184:1:o;24601:404::-;24803:2;24785:21;;;24842:2;24822:18;;;24815:30;24881:34;24876:2;24861:18;;24854:62;-1:-1:-1;;;24947:2:1;24932:18;;24925:38;24995:3;24980:19;;24601:404::o;25010:401::-;25212:2;25194:21;;;25251:2;25231:18;;;25224:30;25290:34;25285:2;25270:18;;25263:62;-1:-1:-1;;;25356:2:1;25341:18;;25334:35;25401:3;25386:19;;25010:401::o;25416:406::-;25618:2;25600:21;;;25657:2;25637:18;;;25630:30;25696:34;25691:2;25676:18;;25669:62;-1:-1:-1;;;25762:2:1;25747:18;;25740:40;25812:3;25797:19;;25416:406::o;25827:465::-;26084:2;26073:9;26066:21;26047:4;26110:56;26162:2;26151:9;26147:18;26139:6;26110:56;:::i;:::-;26214:9;26206:6;26202:22;26197:2;26186:9;26182:18;26175:50;26242:44;26279:6;26271;26242:44;:::i;:::-;26234:52;25827:465;-1:-1:-1;;;;;25827:465:1:o;26682:397::-;26884:2;26866:21;;;26923:2;26903:18;;;26896:30;26962:34;26957:2;26942:18;;26935:62;-1:-1:-1;;;27028:2:1;27013:18;;27006:31;27069:3;27054:19;;26682:397::o;28050:399::-;28252:2;28234:21;;;28291:2;28271:18;;;28264:30;28330:34;28325:2;28310:18;;28303:62;-1:-1:-1;;;28396:2:1;28381:18;;28374:33;28439:3;28424:19;;28050:399::o;28454:400::-;28656:2;28638:21;;;28695:2;28675:18;;;28668:30;28734:34;28729:2;28714:18;;28707:62;-1:-1:-1;;;28800:2:1;28785:18;;28778:34;28844:3;28829:19;;28454:400::o;29622:827::-;-1:-1:-1;;;;;30019:15:1;;;30001:34;;30071:15;;30066:2;30051:18;;30044:43;29981:3;30118:2;30103:18;;30096:31;;;29944:4;;30150:57;;30187:19;;30179:6;30150:57;:::i;:::-;30255:9;30247:6;30243:22;30238:2;30227:9;30223:18;30216:50;30289:44;30326:6;30318;30289:44;:::i;:::-;30275:58;;30382:9;30374:6;30370:22;30364:3;30353:9;30349:19;30342:51;30410:33;30436:6;30428;30410:33;:::i;:::-;30402:41;29622:827;-1:-1:-1;;;;;;;;29622:827:1:o;30454:249::-;30523:6;30576:2;30564:9;30555:7;30551:23;30547:32;30544:52;;;30592:1;30589;30582:12;30544:52;30624:9;30618:16;30643:30;30667:5;30643:30;:::i;30708:179::-;30743:3;30785:1;30767:16;30764:23;30761:120;;;30831:1;30828;30825;30810:23;-1:-1:-1;30868:1:1;30862:8;30857:3;30853:18;30761:120;30708:179;:::o;30892:671::-;30931:3;30973:4;30955:16;30952:26;30949:39;;;30892:671;:::o;30949:39::-;31015:2;31009:9;-1:-1:-1;;31080:16:1;31076:25;;31073:1;31009:9;31052:50;31131:4;31125:11;31155:16;-1:-1:-1;;;;;31261:2:1;31254:4;31246:6;31242:17;31239:25;31234:2;31226:6;31223:14;31220:45;31217:58;;;31268:5;;;;;30892:671;:::o;31217:58::-;31305:6;31299:4;31295:17;31284:28;;31341:3;31335:10;31368:2;31360:6;31357:14;31354:27;;;31374:5;;;;;;30892:671;:::o;31354:27::-;31458:2;31439:16;31433:4;31429:27;31425:36;31418:4;31409:6;31404:3;31400:16;31396:27;31393:69;31390:82;;;31465:5;;;;;;30892:671;:::o;31390:82::-;31481:57;31532:4;31523:6;31515;31511:19;31507:30;31501:4;31481:57;:::i;:::-;-1:-1:-1;31554:3:1;;30892:671;-1:-1:-1;;;;;30892:671:1:o;31989:404::-;32191:2;32173:21;;;32230:2;32210:18;;;32203:30;32269:34;32264:2;32249:18;;32242:62;-1:-1:-1;;;32335:2:1;32320:18;;32313:38;32383:3;32368:19;;31989:404::o;32398:127::-;32459:10;32454:3;32450:20;32447:1;32440:31;32490:4;32487:1;32480:15;32514:4;32511:1;32504:15;33646:561;-1:-1:-1;;;;;33943:15:1;;;33925:34;;33995:15;;33990:2;33975:18;;33968:43;34042:2;34027:18;;34020:34;;;34085:2;34070:18;;34063:34;;;33905:3;34128;34113:19;;34106:32;;;33868:4;;34155:46;;34181:19;;34173:6;34155:46;:::i

Swarm Source

ipfs://26ff64ad8ea4e90cdf7fda70ecc8329842e5fd2e9bff73dc04a2156a1025f5ad

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