Token

Arcana - FlightPass (Arcana)

ERC-721

Overview

Max Total Supply

899 Arcana

Holders

365

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xe9bf295114e836b93df107dccd9b0d1fa8caa0f9

Filtered by Token Holder

0x664bD284a16B9d968522838D5e1d37CdFFdcfDBe

mmo582.eth

Balance

1 Arcana

0x664bD284a16B9d968522838D5e1d37CdFFdcfDBe

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ArcanaFlightPass

Compiler Version

v0.8.19+commit.7dd6d404

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-03-28
*/

// File: ArcanaERC721A.sol_flattened.sol




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

pragma solidity ^0.8.0;


library Counters {
    struct Counter {
        
        uint256 _value; // default: 0
    }

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

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

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

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

// File: @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;
    }

    
    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) {
        
        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/token/ERC721/IERC721Receiver.sol


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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


pragma solidity ^0.8.4;








error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerQueryForNonexistentToken();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string internal _name;

    // Token symbol
    string internal _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See _ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) internal _addressData;

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

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

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

    /**
     * To change the starting tokenId, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function _ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return _ownershipOf(tokenId).addr;
    }

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

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

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

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

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

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

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

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        return _startTokenId() <= tokenId && tokenId < _currentIndex &&
            !_ownerships[tokenId].burned;
    }

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (safe && to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex != end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex != end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();

        bool isApprovedOrOwner = (_msgSender() == from ||
            isApprovedForAll(from, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = to;
            currSlot.startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @dev This is equivalent to _burn(tokenId, false)
     */
    function _burn(uint256 tokenId) internal virtual {
        _burn(tokenId, false);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId, bool approvalCheck) internal virtual {
        TokenOwnership memory prevOwnership = _ownershipOf(tokenId);

        address from = prevOwnership.addr;

        if (approvalCheck) {
            bool isApprovedOrOwner = (_msgSender() == from ||
                isApprovedForAll(from, _msgSender()) ||
                getApproved(tokenId) == _msgSender());

            if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        }

        _beforeTokenTransfers(from, address(0), tokenId, 1);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId, from);

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            AddressData storage addressData = _addressData[from];
            addressData.balance -= 1;
            addressData.numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            TokenOwnership storage currSlot = _ownerships[tokenId];
            currSlot.addr = from;
            currSlot.startTimestamp = uint64(block.timestamp);
            currSlot.burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            TokenOwnership storage nextSlot = _ownerships[nextTokenId];
            if (nextSlot.addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId != _currentIndex) {
                    nextSlot.addr = from;
                    nextSlot.startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, address(0), tokenId);
        _afterTokenTransfers(from, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

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

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkContractOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal returns (bool) {
        try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
            return retval == IERC721Receiver(to).onERC721Received.selector;
        } catch (bytes memory reason) {
            if (reason.length == 0) {
                revert TransferToNonERC721ReceiverImplementer();
            } else {
                assembly {
                    revert(add(32, reason), mload(reason))
                }
            }
        }
    }

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

// File: ArcanaERC721A.sol


pragma solidity ^0.8.9;





contract ArcanaFlightPass is ERC721A, Ownable {
    using Counters for Counters.Counter;
    using ECDSA for bytes32;
    
    uint256 public constant mintPrice = 0.03 ether;
    uint256 public constant PublicmintPrice = 0.036 ether;
    uint256 public constant maxMintPerUser = 2;
    uint256 public constant maxMintSupply = 5555;

    

    address public refundAddress;
    bool public publicMintOpen = false;
    bool public allowListMintOpen = false;
    bool public allowburntoken = false;

    mapping(address => bool) public allowList;

   
    Counters.Counter private _tokenIdCounter;
    address private _signerAddress;

    constructor(address signerAddress_) ERC721A("Arcana - FlightPass", "Arcana") {
        _signerAddress = signerAddress_;
    }

    function _baseURI() internal pure override returns (string memory) {
        return "ipfs://QmWBwhwh8LMuhF1JmuhuxkpmRejsCXWN98S2BXPFAc6Nmz/";
    }

 
    function editMintWindows(
        bool _publicMintOpen,
        bool _allowListMintOpen
    ) external onlyOwner {
        publicMintOpen = _publicMintOpen;
        allowListMintOpen = _allowListMintOpen;
    }

    function safeMint(uint256 quantity, bytes calldata signature) public payable {
        require(allowListMintOpen, "Allowlist Mint Closed");
        require(msg.value >= quantity * mintPrice, "Not enough funds");
        require(_numberMinted(msg.sender) + quantity <= maxMintPerUser, "You reached your Mint limit");
        require(_totalMinted() + quantity <= maxMintSupply, "SOLD OUT");
        require(_signerAddress == keccak256(
            abi.encodePacked(
                "\x19Ethereum Signed Message:\n32",
                bytes32(uint256(uint160(msg.sender)))
            )
        ).recover(signature), "You are not on the allow list.");

        _safeMint(msg.sender, quantity);
      
        for(uint256 i = _currentIndex - quantity; i < _currentIndex; i++){
         
        }
    }


    function publicMint(uint256 quantity) public payable {
        require(publicMintOpen, "Public Mint Closed");
        require(msg.value >= quantity * PublicmintPrice, "Not enough funds");
        require(_numberMinted(msg.sender) + quantity <= (maxMintPerUser + 3) , "You reached your Mint limit");
        require(_totalMinted() + quantity <= maxMintSupply, "SOLD OUT");

        _safeMint(msg.sender, quantity);
      
        for(uint256 i = _currentIndex - quantity; i < _currentIndex; i++){
       
        }
    }

    function adminMint(uint256 quantity) external onlyOwner {
        
        require(_totalMinted() + quantity <= maxMintSupply, "SOLD OUT");

        _safeMint(msg.sender, quantity);
      
        for(uint256 i = _currentIndex - quantity; i < _currentIndex; i++){
       
        }
    }
    
 // Populate the Allow List
    function setAllowList(address[] calldata addresses) external onlyOwner {
        for(uint256 i = 0; i < addresses.length; i++){
            allowList[addresses[i]] = true;
        }
    }

    function removeFromAllowList(address[] calldata addresses)
    external onlyOwner
    {
        for (uint256 i = 0; i < addresses.length; i++) {
             allowList[addresses[i]]= false;
        }
    }

    function Burn(uint256 tokenId) external onlyOwner {
       super._burn(tokenId, false);
    }
    
    
    function withdraw() external onlyOwner {
      
        uint256 balance = address(this).balance;
        Address.sendValue(payable(msg.sender), balance);
    }

    function testBytesReturn() external view returns (bytes32) {
        return bytes32(uint256(uint160(msg.sender)));
    }

    function testSignerRecovery(bytes calldata signature) external view returns (address) {
        return keccak256(
            abi.encodePacked(
                "\x19Ethereum Signed Message:\n32",
                bytes32(uint256(uint160(msg.sender)))
            )
        ).recover(signature);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"signerAddress_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"PublicmintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"adminMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"allowList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowListMintOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"allowburntoken","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_publicMintOpen","type":"bool"},{"internalType":"bool","name":"_allowListMintOpen","type":"bool"}],"name":"editMintWindows","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintPerUser","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"publicMintOpen","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"refundAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"removeFromAllowList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"quantity","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"safeMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"addresses","type":"address[]"}],"name":"setAllowList","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":"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":[],"name":"testBytesReturn","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"testSignerRecovery","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

00000000000000000000000046daf13104a27304552c709513423a14d72a21f1

-----Decoded View---------------
Arg [0] : signerAddress_ (address): 0x46DAF13104A27304552c709513423A14d72A21F1

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000046daf13104a27304552c709513423a14d72a21f1

Deployed Bytecode Sourcemap

67681:4018:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49853:305;;;;;;;;;;-1:-1:-1;49853:305:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;49853:305:0;;;;;;;;67865:53;;;;;;;;;;;;67907:11;67865:53;;;;;738:25:1;;;726:2;711:18;67865:53:0;592:177:1;52966:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;54469:204::-;;;;;;;;;;-1:-1:-1;54469:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1879:32:1;;;1861:51;;1849:2;1834:18;54469:204:0;1715:203:1;68111:37:0;;;;;;;;;;-1:-1:-1;68111:37:0;;;;-1:-1:-1;;;68111:37:0;;;;;;54032:371;;;;;;;;;;-1:-1:-1;54032:371:0;;;;;:::i;:::-;;:::i;:::-;;68035:28;;;;;;;;;;-1:-1:-1;68035:28:0;;;;-1:-1:-1;;;;;68035:28:0;;;49102:303;;;;;;;;;;-1:-1:-1;49356:12:0;;49146:7;49340:13;:28;49102:303;;55334:170;;;;;;;;;;-1:-1:-1;55334:170:0;;;;;:::i;:::-;;:::i;68198:41::-;;;;;;;;;;-1:-1:-1;68198:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;69683:530;;;;;;:::i;:::-;;:::i;68634:216::-;;;;;;;;;;-1:-1:-1;68634:216:0;;;;;:::i;:::-;;:::i;71089:163::-;;;;;;;;;;;;;:::i;55575:185::-;;;;;;;;;;-1:-1:-1;55575:185:0;;;;;:::i;:::-;;:::i;52774:125::-;;;;;;;;;;-1:-1:-1;52774:125:0;;;;;:::i;:::-;;:::i;70558:191::-;;;;;;;;;;-1:-1:-1;70558:191:0;;;;;:::i;:::-;;:::i;67812:46::-;;;;;;;;;;;;67848:10;67812:46;;50222:206;;;;;;;;;;-1:-1:-1;50222:206:0;;;;;:::i;:::-;;:::i;26484:103::-;;;;;;;;;;;;;:::i;25836:87::-;;;;;;;;;;-1:-1:-1;25909:6:0;;-1:-1:-1;;;;;25909:6:0;25836:87;;53135:104;;;;;;;;;;;;;:::i;54745:287::-;;;;;;;;;;-1:-1:-1;54745:287:0;;;;;:::i;:::-;;:::i;70757:211::-;;;;;;;;;;-1:-1:-1;70757:211:0;;;;;:::i;:::-;;:::i;68155:34::-;;;;;;;;;;-1:-1:-1;68155:34:0;;;;-1:-1:-1;;;68155:34:0;;;;;;55831:369;;;;;;;;;;-1:-1:-1;55831:369:0;;;;;:::i;:::-;;:::i;70976:95::-;;;;;;;;;;-1:-1:-1;70976:95:0;;;;;:::i;:::-;;:::i;68070:34::-;;;;;;;;;;-1:-1:-1;68070:34:0;;;;-1:-1:-1;;;68070:34:0;;;;;;70221:296;;;;;;;;;;-1:-1:-1;70221:296:0;;;;;:::i;:::-;;:::i;67974:44::-;;;;;;;;;;;;68014:4;67974:44;;53310:318;;;;;;;;;;-1:-1:-1;53310:318:0;;;;;:::i;:::-;;:::i;71390:306::-;;;;;;;;;;-1:-1:-1;71390:306:0;;;;;:::i;:::-;;:::i;67925:42::-;;;;;;;;;;;;67966:1;67925:42;;71260:122;;;;;;;;;;-1:-1:-1;71361:10:0;71260:122;;55103:164;;;;;;;;;;-1:-1:-1;55103:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;55224:25:0;;;55200:4;55224:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;55103:164;68858:815;;;;;;:::i;:::-;;:::i;26742:201::-;;;;;;;;;;-1:-1:-1;26742:201:0;;;;;:::i;:::-;;:::i;49853:305::-;49955:4;-1:-1:-1;;;;;;49992:40:0;;-1:-1:-1;;;49992:40:0;;:105;;-1:-1:-1;;;;;;;50049:48:0;;-1:-1:-1;;;50049:48:0;49992:105;:158;;;-1:-1:-1;;;;;;;;;;39674:40:0;;;50114:36;49972:178;49853:305;-1:-1:-1;;49853:305:0:o;52966:100::-;53020:13;53053:5;53046:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52966:100;:::o;54469:204::-;54537:7;54562:16;54570:7;54562;:16::i;:::-;54557:64;;54587:34;;-1:-1:-1;;;54587:34:0;;;;;;;;;;;54557:64;-1:-1:-1;54641:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;54641:24:0;;54469:204::o;54032:371::-;54105:13;54121:24;54137:7;54121:15;:24::i;:::-;54105:40;;54166:5;-1:-1:-1;;;;;54160:11:0;:2;-1:-1:-1;;;;;54160:11:0;;54156:48;;54180:24;;-1:-1:-1;;;54180:24:0;;;;;;;;;;;54156:48;24467:10;-1:-1:-1;;;;;54221:21:0;;;;;;:63;;-1:-1:-1;54247:37:0;54264:5;24467:10;55103:164;:::i;54247:37::-;54246:38;54221:63;54217:138;;;54308:35;;-1:-1:-1;;;54308:35:0;;;;;;;;;;;54217:138;54367:28;54376:2;54380:7;54389:5;54367:8;:28::i;:::-;54094:309;54032:371;;:::o;55334:170::-;55468:28;55478:4;55484:2;55488:7;55468:9;:28::i;69683:530::-;69755:14;;-1:-1:-1;;;69755:14:0;;;;69747:45;;;;-1:-1:-1;;;69747:45:0;;7738:2:1;69747:45:0;;;7720:21:1;7777:2;7757:18;;;7750:30;-1:-1:-1;;;7796:18:1;;;7789:48;7854:18;;69747:45:0;;;;;;;;;69824:26;67907:11;69824:8;:26;:::i;:::-;69811:9;:39;;69803:68;;;;-1:-1:-1;;;69803:68:0;;8390:2:1;69803:68:0;;;8372:21:1;8429:2;8409:18;;;8402:30;-1:-1:-1;;;8448:18:1;;;8441:46;8504:18;;69803:68:0;8188:340:1;69803:68:0;69931:18;67966:1;69948;69931:18;:::i;:::-;69904:10;50571:7;50606:19;;;:12;:19;;;;;:32;69918:8;;-1:-1:-1;;;50606:32:0;;-1:-1:-1;;;;;50606:32:0;69890:36;;;;:::i;:::-;:60;;69882:101;;;;-1:-1:-1;;;69882:101:0;;8865:2:1;69882:101:0;;;8847:21:1;8904:2;8884:18;;;8877:30;8943:29;8923:18;;;8916:57;8990:18;;69882:101:0;8663:351:1;69882:101:0;68014:4;70019:8;70002:14;49545:7;49731:13;;49498:283;70002:14;:25;;;;:::i;:::-;:42;;69994:63;;;;-1:-1:-1;;;69994:63:0;;;;;;;:::i;:::-;70070:31;70080:10;70092:8;70070:9;:31::i;:::-;70124:9;70152:8;70136:13;;:24;;;;:::i;:::-;70124:36;;70120:86;70166:13;;70162:1;:17;70120:86;;;70181:3;;;;:::i;:::-;;;;70120:86;;;;69683:530;:::o;68634:216::-;25722:13;:11;:13::i;:::-;68761:14:::1;:32:::0;;-1:-1:-1;;;;68804:38:0;-1:-1:-1;;;68761:32:0;::::1;;::::0;;;::::1;-1:-1:-1::0;;;;68804:38:0;;;;;-1:-1:-1;;;68804:38:0;::::1;;::::0;;;::::1;;::::0;;68634:216::o;71089:163::-;25722:13;:11;:13::i;:::-;71165:21:::1;71197:47;71223:10;71165:21:::0;71197:17:::1;:47::i;:::-;71128:124;71089:163::o:0;55575:185::-;55713:39;55730:4;55736:2;55740:7;55713:39;;;;;;;;;;;;:16;:39::i;52774:125::-;52838:7;52865:21;52878:7;52865:12;:21::i;:::-;:26;;52774:125;-1:-1:-1;;52774:125:0:o;70558:191::-;25722:13;:11;:13::i;:::-;70644:9:::1;70640:102;70659:20:::0;;::::1;70640:102;;;70726:4;70700:9;:23;70710:9;;70720:1;70710:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;70700:23:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;70700:23:0;:30;;-1:-1:-1;;70700:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;70681:3;::::1;::::0;::::1;:::i;:::-;;;;70640:102;;50222:206:::0;50286:7;-1:-1:-1;;;;;50310:19:0;;50306:60;;50338:28;;-1:-1:-1;;;50338:28:0;;;;;;;;;;;50306:60;-1:-1:-1;;;;;;50392:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;50392:27:0;;50222:206::o;26484:103::-;25722:13;:11;:13::i;:::-;26549:30:::1;26576:1;26549:18;:30::i;:::-;26484:103::o:0;53135:104::-;53191:13;53224:7;53217:14;;;;;:::i;54745:287::-;24467:10;-1:-1:-1;;;;;54844:24:0;;;54840:54;;54877:17;;-1:-1:-1;;;54877:17:0;;;;;;;;;;;54840:54;24467:10;54907:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;54907:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;54907:53:0;;;;;;;;;;54976:48;;540:41:1;;;54907:42:0;;24467:10;54976:48;;513:18:1;54976:48:0;;;;;;;54745:287;;:::o;70757:211::-;25722:13;:11;:13::i;:::-;70861:9:::1;70856:105;70876:20:::0;;::::1;70856:105;;;70944:5;70919:9;:23;70929:9;;70939:1;70929:12;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;70919:23:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;70919:23:0;:30;;-1:-1:-1;;70919:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;70898:3;::::1;::::0;::::1;:::i;:::-;;;;70856:105;;55831:369:::0;55998:28;56008:4;56014:2;56018:7;55998:9;:28::i;:::-;-1:-1:-1;;;;;56041:13:0;;28829:19;:23;;56041:76;;;;;56061:56;56092:4;56098:2;56102:7;56111:5;56061:30;:56::i;:::-;56060:57;56041:76;56037:156;;;56141:40;;-1:-1:-1;;;56141:40:0;;;;;;;;;;;56037:156;55831:369;;;;:::o;70976:95::-;25722:13;:11;:13::i;:::-;71036:27:::1;71048:7;71057:5;71036:11;:27::i;70221:296::-:0;25722:13;:11;:13::i;:::-;68014:4:::1;70323:8;70306:14;49545:7:::0;49731:13;;49498:283;70306:14:::1;:25;;;;:::i;:::-;:42;;70298:63;;;;-1:-1:-1::0;;;70298:63:0::1;;;;;;;:::i;:::-;70374:31;70384:10;70396:8;70374:9;:31::i;:::-;70428:9;70456:8;70440:13;;:24;;;;:::i;:::-;70428:36;;70424:86;70470:13;;70466:1;:17;70424:86;;;70485:3:::0;::::1;::::0;::::1;:::i;:::-;;;;70424:86;;53310:318:::0;53383:13;53414:16;53422:7;53414;:16::i;:::-;53409:59;;53439:29;;-1:-1:-1;;;53439:29:0;;;;;;;;;;;53409:59;53481:21;53505:10;:8;:10::i;:::-;53481:34;;53539:7;53533:21;53558:1;53533:26;:87;;;;;;;;;;;;;;;;;53586:7;53595:18;:7;:16;:18::i;:::-;53569:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;53533:87;53526:94;53310:318;-1:-1:-1;;;53310:318:0:o;71390:306::-;71467:7;71494:194;71678:9;;71494:194;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;71518:140:0;;10503:66:1;71518:140:0;;;10491:79:1;71630:10:0;10586:12:1;;;10579:28;10623:12;;;-1:-1:-1;71518:140:0;;-1:-1:-1;10261:380:1;71518:140:0;;;;;;;;;;;;;71494:175;;;;;;:183;;:194;;;;:::i;68858:815::-;68954:17;;-1:-1:-1;;;68954:17:0;;;;68946:51;;;;-1:-1:-1;;;68946:51:0;;10848:2:1;68946:51:0;;;10830:21:1;10887:2;10867:18;;;10860:30;-1:-1:-1;;;10906:18:1;;;10899:51;10967:18;;68946:51:0;10646:345:1;68946:51:0;69029:20;67848:10;69029:8;:20;:::i;:::-;69016:9;:33;;69008:62;;;;-1:-1:-1;;;69008:62:0;;8390:2:1;69008:62:0;;;8372:21:1;8429:2;8409:18;;;8402:30;-1:-1:-1;;;8448:18:1;;;8441:46;8504:18;;69008:62:0;8188:340:1;69008:62:0;69103:10;50571:7;50606:19;;;:12;:19;;;;;:32;67966:1;;69117:8;;-1:-1:-1;;;50606:32:0;;-1:-1:-1;;;;;50606:32:0;69089:36;;;;:::i;:::-;:54;;69081:94;;;;-1:-1:-1;;;69081:94:0;;8865:2:1;69081:94:0;;;8847:21:1;8904:2;8884:18;;;8877:30;8943:29;8923:18;;;8916:57;8990:18;;69081:94:0;8663:351:1;69081:94:0;68014:4;69211:8;69194:14;49545:7;49731:13;;49498:283;69194:14;:25;;;;:::i;:::-;:42;;69186:63;;;;-1:-1:-1;;;69186:63:0;;;;;;;:::i;:::-;69286:194;69470:9;;69286:194;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;69310:140:0;;10503:66:1;69310:140:0;;;10491:79:1;69422:10:0;10586:12:1;;;10579:28;10623:12;;;-1:-1:-1;69310:140:0;;-1:-1:-1;10261:380:1;69286:194:0;69268:14;;-1:-1:-1;;;;;69268:14:0;;;:212;;;69260:255;;;;-1:-1:-1;;;69260:255:0;;11198:2:1;69260:255:0;;;11180:21:1;11237:2;11217:18;;;11210:30;11276:32;11256:18;;;11249:60;11326:18;;69260:255:0;10996:354:1;69260:255:0;69528:31;69538:10;69550:8;69528:9;:31::i;:::-;69582:9;69610:8;69594:13;;:24;;;;:::i;:::-;69582:36;;69578:88;69624:13;;69620:1;:17;69578:88;;;69639:3;;;;:::i;:::-;;;;69578:88;;26742:201;25722:13;:11;:13::i;:::-;-1:-1:-1;;;;;26831:22:0;::::1;26823:73;;;::::0;-1:-1:-1;;;26823:73:0;;11557:2:1;26823:73:0::1;::::0;::::1;11539:21:1::0;11596:2;11576:18;;;11569:30;11635:34;11615:18;;;11608:62;-1:-1:-1;;;11686:18:1;;;11679:36;11732:19;;26823:73:0::1;11355:402:1::0;26823:73:0::1;26907:28;26926:8;26907:18;:28::i;56455:187::-:0;56512:4;56576:13;;56566:7;:23;56536:98;;;;-1:-1:-1;;56607:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;56607:27:0;;;;56606:28;;56455:187::o;64626:197::-;64742:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;64742:29:0;-1:-1:-1;;;;;64742:29:0;;;;;;;;;64787:28;;64742:24;;64787:28;;;;;;;64626:197;;;:::o;59568:2131::-;59684:35;59722:21;59735:7;59722:12;:21::i;:::-;59684:59;;59782:4;-1:-1:-1;;;;;59760:26:0;:13;:18;;;-1:-1:-1;;;;;59760:26:0;;59756:67;;59795:28;;-1:-1:-1;;;59795:28:0;;;;;;;;;;;59756:67;59836:22;24467:10;-1:-1:-1;;;;;59862:20:0;;;;:73;;-1:-1:-1;59899:36:0;59916:4;24467:10;55103:164;:::i;59899:36::-;59862:126;;;-1:-1:-1;24467:10:0;59952:20;59964:7;59952:11;:20::i;:::-;-1:-1:-1;;;;;59952:36:0;;59862:126;59836:153;;60007:17;60002:66;;60033:35;;-1:-1:-1;;;60033:35:0;;;;;;;;;;;60002:66;-1:-1:-1;;;;;60083:16:0;;60079:52;;60108:23;;-1:-1:-1;;;60108:23:0;;;;;;;;;;;60079:52;60252:35;60269:1;60273:7;60282:4;60252:8;:35::i;:::-;-1:-1:-1;;;;;60583:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;60583:31:0;;;-1:-1:-1;;;;;60583:31:0;;;-1:-1:-1;;60583:31:0;;;;;;;60629:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;60629:29:0;;;;;;;;;;;60709:20;;;:11;:20;;;;;;60744:18;;-1:-1:-1;;;;;;60777:49:0;;;;-1:-1:-1;;;60810:15:0;60777:49;;;;;;;;;;61100:11;;61160:24;;;;;61203:13;;60709:20;;61160:24;;61203:13;61199:384;;61413:13;;61398:11;:28;61394:174;;61451:20;;61520:28;;;;-1:-1:-1;;;;;61494:54:0;-1:-1:-1;;;61494:54:0;-1:-1:-1;;;;;;61494:54:0;;;-1:-1:-1;;;;;61451:20:0;;61494:54;;;;61394:174;60558:1036;;;61630:7;61626:2;-1:-1:-1;;;;;61611:27:0;61620:4;-1:-1:-1;;;;;61611:27:0;-1:-1:-1;;;;;;;;;;;61611:27:0;;;;;;;;;61649:42;59673:2026;;59568:2131;;;:::o;56650:104::-;56719:27;56729:2;56733:8;56719:27;;;;;;;;;;;;:9;:27::i;26001:132::-;25909:6;;-1:-1:-1;;;;;25909:6:0;24467:10;26065:23;26057:68;;;;-1:-1:-1;;;26057:68:0;;11964:2:1;26057:68:0;;;11946:21:1;;;11983:18;;;11976:30;12042:34;12022:18;;;12015:62;12094:18;;26057:68:0;11762:356:1;29795:317:0;29910:6;29885:21;:31;;29877:73;;;;-1:-1:-1;;;29877:73:0;;12325:2:1;29877:73:0;;;12307:21:1;12364:2;12344:18;;;12337:30;12403:31;12383:18;;;12376:59;12452:18;;29877:73:0;12123:353:1;29877:73:0;29964:12;29982:9;-1:-1:-1;;;;;29982:14:0;30004:6;29982:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29963:52;;;30034:7;30026:78;;;;-1:-1:-1;;;30026:78:0;;12893:2:1;30026:78:0;;;12875:21:1;12932:2;12912:18;;;12905:30;12971:34;12951:18;;;12944:62;13042:28;13022:18;;;13015:56;13088:19;;30026:78:0;12691:422:1;51603:1109:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;51714:7:0;51797:13;;51790:4;:20;51759:886;;;51831:31;51865:17;;;:11;:17;;;;;;;;;51831:51;;;;;;;;;-1:-1:-1;;;;;51831:51:0;;;;-1:-1:-1;;;51831:51:0;;-1:-1:-1;;;;;51831:51:0;;;;;;;;-1:-1:-1;;;51831:51:0;;;;;;;;;;;;;;51901:729;;51951:14;;-1:-1:-1;;;;;51951:28:0;;51947:101;;52015:9;51603:1109;-1:-1:-1;;;51603:1109:0:o;51947:101::-;-1:-1:-1;;;52390:6:0;52435:17;;;;:11;:17;;;;;;;;;52423:29;;;;;;;;;-1:-1:-1;;;;;52423:29:0;;;;;-1:-1:-1;;;52423:29:0;;-1:-1:-1;;;;;52423:29:0;;;;;;;;-1:-1:-1;;;52423:29:0;;;;;;;;;;;;;52483:28;52479:109;;52551:9;51603:1109;-1:-1:-1;;;51603:1109:0:o;52479:109::-;52350:261;;;51812:833;51759:886;52673:31;;-1:-1:-1;;;52673:31:0;;;;;;;;;;;27103:191;27196:6;;;-1:-1:-1;;;;;27213:17:0;;;-1:-1:-1;;;;;;27213:17:0;;;;;;;27246:40;;27196:6;;;27213:17;27196:6;;27246:40;;27177:16;;27246:40;27166:128;27103:191;:::o;65315:668::-;65500:72;;-1:-1:-1;;;65500:72:0;;65479:4;;-1:-1:-1;;;;;65500:36:0;;;;;:72;;24467:10;;65551:4;;65557:7;;65566:5;;65500:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65500:72:0;;;;;;;;-1:-1:-1;;65500:72:0;;;;;;;;;;;;:::i;:::-;;;65496:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65734:6;:13;65751:1;65734:18;65730:235;;65780:40;;-1:-1:-1;;;65780:40:0;;;;;;;;;;;65730:235;65923:6;65917:13;65908:6;65904:2;65900:15;65893:38;65496:480;-1:-1:-1;;;;;;65619:55:0;-1:-1:-1;;;65619:55:0;;-1:-1:-1;65315:668:0;;;;;;:::o;62100:2408::-;62180:35;62218:21;62231:7;62218:12;:21::i;:::-;62267:18;;62180:59;;-1:-1:-1;62298:290:0;;;;62332:22;24467:10;-1:-1:-1;;;;;62358:20:0;;;;:77;;-1:-1:-1;62399:36:0;62416:4;24467:10;55103:164;:::i;62399:36::-;62358:134;;;-1:-1:-1;24467:10:0;62456:20;62468:7;62456:11;:20::i;:::-;-1:-1:-1;;;;;62456:36:0;;62358:134;62332:161;;62515:17;62510:66;;62541:35;;-1:-1:-1;;;62541:35:0;;;;;;;;;;;62510:66;62317:271;62298:290;62716:35;62733:1;62737:7;62746:4;62716:8;:35::i;:::-;-1:-1:-1;;;;;63081:18:0;;;63047:31;63081:18;;;:12;:18;;;;;;;;63114:24;;-1:-1:-1;;;;;;;;;;63114:24:0;;;;;;;;;-1:-1:-1;;63114:24:0;;;;63153:29;;;;;63137:1;63153:29;;;;;;;;-1:-1:-1;;63153:29:0;;;;;;;;;;63315:20;;;:11;:20;;;;;;63350;;-1:-1:-1;;;;63418:15:0;63385:49;;;-1:-1:-1;;;63385:49:0;-1:-1:-1;;;;;;63385:49:0;;;;;;;;;;63449:22;-1:-1:-1;;;63449:22:0;;;63741:11;;;63801:24;;;;;63844:13;;63081:18;;63801:24;;63844:13;63840:384;;64054:13;;64039:11;:28;64035:174;;64092:20;;64161:28;;;;-1:-1:-1;;;;;64135:54:0;-1:-1:-1;;;64135:54:0;-1:-1:-1;;;;;;64135:54:0;;;-1:-1:-1;;;;;64092:20:0;;64135:54;;;;64035:174;-1:-1:-1;;64252:35:0;;64279:7;;-1:-1:-1;64275:1:0;;-1:-1:-1;;;;;;64252:35:0;;;-1:-1:-1;;;;;;;;;;;64252:35:0;64275:1;;64252:35;-1:-1:-1;;64475:12:0;:14;;;;;;-1:-1:-1;;62100:2408:0:o;68474:149::-;68526:13;68552:63;;;;;;;;;;;;;;;;;;;68474:149;:::o;13926:716::-;13982:13;14033:14;14050:17;14061:5;14050:10;:17::i;:::-;14070:1;14050:21;14033:38;;14086:20;14120:6;-1:-1:-1;;;;;14109:18:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14109:18:0;-1:-1:-1;14086:41:0;-1:-1:-1;14251:28:0;;;14267:2;14251:28;14308:288;-1:-1:-1;;14340:5:0;-1:-1:-1;;;14477:2:0;14466:14;;14461:30;14340:5;14448:44;14538:2;14529:11;;;-1:-1:-1;14559:21:0;14308:288;14559:21;-1:-1:-1;14617:6:0;13926:716;-1:-1:-1;;;13926:716:0:o;19576:231::-;19654:7;19675:17;19694:18;19716:27;19727:4;19733:9;19716:10;:27::i;:::-;19674:69;;;;19754:18;19766:5;19754:11;:18::i;:::-;-1:-1:-1;19790:9:0;19576:231;-1:-1:-1;;;19576:231:0:o;57117:163::-;57240:32;57246:2;57250:8;57260:5;57267:4;57240:5;:32::i;10792:922::-;10845:7;;-1:-1:-1;;;10923:15:0;;10919:102;;-1:-1:-1;;;10959:15:0;;;-1:-1:-1;11003:2:0;10993:12;10919:102;11048:6;11039:5;:15;11035:102;;11084:6;11075:15;;;-1:-1:-1;11119:2:0;11109:12;11035:102;11164:6;11155:5;:15;11151:102;;11200:6;11191:15;;;-1:-1:-1;11235:2:0;11225:12;11151:102;11280:5;11271;:14;11267:99;;11315:5;11306:14;;;-1:-1:-1;11349:1:0;11339:11;11267:99;11393:5;11384;:14;11380:99;;11428:5;11419:14;;;-1:-1:-1;11462:1:0;11452:11;11380:99;11506:5;11497;:14;11493:99;;11541:5;11532:14;;;-1:-1:-1;11575:1:0;11565:11;11493:99;11619:5;11610;:14;11606:66;;11655:1;11645:11;11700:6;10792:922;-1:-1:-1;;10792:922:0:o;18027:747::-;18108:7;18117:12;18146:9;:16;18166:2;18146:22;18142:625;;18490:4;18475:20;;18469:27;18540:4;18525:20;;18519:27;18598:4;18583:20;;18577:27;18185:9;18569:36;18641:25;18652:4;18569:36;18469:27;18519;18641:10;:25::i;:::-;18634:32;;;;;;;;;18142:625;-1:-1:-1;18715:1:0;;-1:-1:-1;18719:35:0;18142:625;18027:747;;;;;:::o;16420:521::-;16498:20;16489:5;:29;;;;;;;;:::i;:::-;;16485:449;;16420:521;:::o;16485:449::-;16596:29;16587:5;:38;;;;;;;;:::i;:::-;;16583:351;;16642:34;;-1:-1:-1;;;16642:34:0;;14332:2:1;16642:34:0;;;14314:21:1;14371:2;14351:18;;;14344:30;14410:26;14390:18;;;14383:54;14454:18;;16642:34:0;14130:348:1;16583:351:0;16707:35;16698:5;:44;;;;;;;;:::i;:::-;;16694:240;;16759:41;;-1:-1:-1;;;16759:41:0;;14685:2:1;16759:41:0;;;14667:21:1;14724:2;14704:18;;;14697:30;14763:33;14743:18;;;14736:61;14814:18;;16759:41:0;14483:355:1;16694:240:0;16831:30;16822:5;:39;;;;;;;;:::i;:::-;;16818:116;;16878:44;;-1:-1:-1;;;16878:44:0;;15045:2:1;16878:44:0;;;15027:21:1;15084:2;15064:18;;;15057:30;15123:34;15103:18;;;15096:62;-1:-1:-1;;;15174:18:1;;;15167:32;15216:19;;16878:44:0;14843:398:1;57539:1775:0;57678:20;57701:13;-1:-1:-1;;;;;57729:16:0;;57725:48;;57754:19;;-1:-1:-1;;;57754:19:0;;;;;;;;;;;57725:48;57788:8;57800:1;57788:13;57784:44;;57810:18;;-1:-1:-1;;;57810:18:0;;;;;;;;;;;57784:44;-1:-1:-1;;;;;58179:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;58238:49:0;;-1:-1:-1;;;;;58179:44:0;;;;;;;58238:49;;;-1:-1:-1;;;;;58179:44:0;;;;;;58238:49;;;;;;;;;;;;;;;;58304:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;58354:66:0;;;;-1:-1:-1;;;58404:15:0;58354:66;;;;;;;;;;58304:25;58501:23;;;58545:4;:23;;;;-1:-1:-1;;;;;;58553:13:0;;28829:19;:23;;58553:15;58541:641;;;58589:314;58620:38;;58645:12;;-1:-1:-1;;;;;58620:38:0;;;58637:1;;-1:-1:-1;;;;;;;;;;;58620:38:0;58637:1;;58620:38;58686:69;58725:1;58729:2;58733:14;;;;;;58749:5;58686:30;:69::i;:::-;58681:174;;58791:40;;-1:-1:-1;;;58791:40:0;;;;;;;;;;;58681:174;58898:3;58882:12;:19;58589:314;;58984:12;58967:13;;:29;58963:43;;58998:8;;;58963:43;58541:641;;;59047:120;59078:40;;59103:14;;;;;-1:-1:-1;;;;;59078:40:0;;;59095:1;;-1:-1:-1;;;;;;;;;;;59078:40:0;59095:1;;59078:40;59162:3;59146:12;:19;59047:120;;58541:641;-1:-1:-1;59196:13:0;:28;59246:60;55831:369;21028:647;21159:7;;21220:66;21207:79;;21203:163;;;-1:-1:-1;21319:1:0;;-1:-1:-1;21323:30:0;21303:51;;21203:163;21480:24;;;21463:14;21480:24;;;;;;;;;15473:25:1;;;15546:4;15534:17;;15514:18;;;15507:45;;;;15568:18;;;15561:34;;;15611:18;;;15604:34;;;21480:24:0;;15445:19:1;;21480:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;21480:24:0;;-1:-1:-1;;21480:24:0;;;-1:-1:-1;;;;;;;21519:20:0;;21515:103;;21572:1;21576:29;21556:50;;;;;;;21515:103;21638:6;-1:-1:-1;21646:20:0;;-1:-1:-1;21028:647:0;;;;;;;;:::o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;774:250::-;859:1;869:113;883:6;880:1;877:13;869:113;;;959:11;;;953:18;940:11;;;933:39;905:2;898:10;869:113;;;-1:-1:-1;;1016:1:1;998:16;;991:27;774:250::o;1029:271::-;1071:3;1109:5;1103:12;1136:6;1131:3;1124:19;1152:76;1221:6;1214:4;1209:3;1205:14;1198:4;1191:5;1187:16;1152:76;:::i;:::-;1282:2;1261:15;-1:-1:-1;;1257:29:1;1248:39;;;;1289:4;1244:50;;1029:271;-1:-1:-1;;1029:271:1:o;1305:220::-;1454:2;1443:9;1436:21;1417:4;1474:45;1515:2;1504:9;1500:18;1492:6;1474:45;:::i;1530:180::-;1589:6;1642:2;1630:9;1621:7;1617:23;1613:32;1610:52;;;1658:1;1655;1648:12;1610:52;-1:-1:-1;1681:23:1;;1530:180;-1:-1:-1;1530:180:1:o;1923:173::-;1991:20;;-1:-1:-1;;;;;2040:31:1;;2030:42;;2020:70;;2086:1;2083;2076:12;2020:70;1923:173;;;:::o;2101:254::-;2169:6;2177;2230:2;2218:9;2209:7;2205:23;2201:32;2198:52;;;2246:1;2243;2236:12;2198:52;2269:29;2288:9;2269:29;:::i;:::-;2259:39;2345:2;2330:18;;;;2317:32;;-1:-1:-1;;;2101:254:1:o;2360:328::-;2437:6;2445;2453;2506:2;2494:9;2485:7;2481:23;2477:32;2474:52;;;2522:1;2519;2512:12;2474:52;2545:29;2564:9;2545:29;:::i;:::-;2535:39;;2593:38;2627:2;2616:9;2612:18;2593:38;:::i;:::-;2583:48;;2678:2;2667:9;2663:18;2650:32;2640:42;;2360:328;;;;;:::o;2693:186::-;2752:6;2805:2;2793:9;2784:7;2780:23;2776:32;2773:52;;;2821:1;2818;2811:12;2773:52;2844:29;2863:9;2844:29;:::i;2884:160::-;2949:20;;3005:13;;2998:21;2988:32;;2978:60;;3034:1;3031;3024:12;3049:248;3111:6;3119;3172:2;3160:9;3151:7;3147:23;3143:32;3140:52;;;3188:1;3185;3178:12;3140:52;3211:26;3227:9;3211:26;:::i;:::-;3201:36;;3256:35;3287:2;3276:9;3272:18;3256:35;:::i;:::-;3246:45;;3049:248;;;;;:::o;3302:615::-;3388:6;3396;3449:2;3437:9;3428:7;3424:23;3420:32;3417:52;;;3465:1;3462;3455:12;3417:52;3505:9;3492:23;-1:-1:-1;;;;;3575:2:1;3567:6;3564:14;3561:34;;;3591:1;3588;3581:12;3561:34;3629:6;3618:9;3614:22;3604:32;;3674:7;3667:4;3663:2;3659:13;3655:27;3645:55;;3696:1;3693;3686:12;3645:55;3736:2;3723:16;3762:2;3754:6;3751:14;3748:34;;;3778:1;3775;3768:12;3748:34;3831:7;3826:2;3816:6;3813:1;3809:14;3805:2;3801:23;3797:32;3794:45;3791:65;;;3852:1;3849;3842:12;3791:65;3883:2;3875:11;;;;;3905:6;;-1:-1:-1;3302:615:1;;-1:-1:-1;;;;3302:615:1:o;3922:254::-;3987:6;3995;4048:2;4036:9;4027:7;4023:23;4019:32;4016:52;;;4064:1;4061;4054:12;4016:52;4087:29;4106:9;4087:29;:::i;4181:127::-;4242:10;4237:3;4233:20;4230:1;4223:31;4273:4;4270:1;4263:15;4297:4;4294:1;4287:15;4313:1138;4408:6;4416;4424;4432;4485:3;4473:9;4464:7;4460:23;4456:33;4453:53;;;4502:1;4499;4492:12;4453:53;4525:29;4544:9;4525:29;:::i;:::-;4515:39;;4573:38;4607:2;4596:9;4592:18;4573:38;:::i;:::-;4563:48;;4658:2;4647:9;4643:18;4630:32;4620:42;;4713:2;4702:9;4698:18;4685:32;-1:-1:-1;;;;;4777:2:1;4769:6;4766:14;4763:34;;;4793:1;4790;4783:12;4763:34;4831:6;4820:9;4816:22;4806:32;;4876:7;4869:4;4865:2;4861:13;4857:27;4847:55;;4898:1;4895;4888:12;4847:55;4934:2;4921:16;4956:2;4952;4949:10;4946:36;;;4962:18;;:::i;:::-;5037:2;5031:9;5005:2;5091:13;;-1:-1:-1;;5087:22:1;;;5111:2;5083:31;5079:40;5067:53;;;5135:18;;;5155:22;;;5132:46;5129:72;;;5181:18;;:::i;:::-;5221:10;5217:2;5210:22;5256:2;5248:6;5241:18;5296:7;5291:2;5286;5282;5278:11;5274:20;5271:33;5268:53;;;5317:1;5314;5307:12;5268:53;5373:2;5368;5364;5360:11;5355:2;5347:6;5343:15;5330:46;5418:1;5413:2;5408;5400:6;5396:15;5392:24;5385:35;5439:6;5429:16;;;;;;;4313:1138;;;;;;;:::o;5456:347::-;5507:8;5517:6;5571:3;5564:4;5556:6;5552:17;5548:27;5538:55;;5589:1;5586;5579:12;5538:55;-1:-1:-1;5612:20:1;;-1:-1:-1;;;;;5644:30:1;;5641:50;;;5687:1;5684;5677:12;5641:50;5724:4;5716:6;5712:17;5700:29;;5776:3;5769:4;5760:6;5752;5748:19;5744:30;5741:39;5738:59;;;5793:1;5790;5783:12;5808:409;5878:6;5886;5939:2;5927:9;5918:7;5914:23;5910:32;5907:52;;;5955:1;5952;5945:12;5907:52;5995:9;5982:23;-1:-1:-1;;;;;6020:6:1;6017:30;6014:50;;;6060:1;6057;6050:12;6014:50;6099:58;6149:7;6140:6;6129:9;6125:22;6099:58;:::i;:::-;6176:8;;6073:84;;-1:-1:-1;5808:409:1;-1:-1:-1;;;;5808:409:1:o;6404:260::-;6472:6;6480;6533:2;6521:9;6512:7;6508:23;6504:32;6501:52;;;6549:1;6546;6539:12;6501:52;6572:29;6591:9;6572:29;:::i;:::-;6562:39;;6620:38;6654:2;6643:9;6639:18;6620:38;:::i;6669:477::-;6748:6;6756;6764;6817:2;6805:9;6796:7;6792:23;6788:32;6785:52;;;6833:1;6830;6823:12;6785:52;6869:9;6856:23;6846:33;;6930:2;6919:9;6915:18;6902:32;-1:-1:-1;;;;;6949:6:1;6946:30;6943:50;;;6989:1;6986;6979:12;6943:50;7028:58;7078:7;7069:6;7058:9;7054:22;7028:58;:::i;:::-;6669:477;;7105:8;;-1:-1:-1;7002:84:1;;-1:-1:-1;;;;6669:477:1:o;7151:380::-;7230:1;7226:12;;;;7273;;;7294:61;;7348:4;7340:6;7336:17;7326:27;;7294:61;7401:2;7393:6;7390:14;7370:18;7367:38;7364:161;;7447:10;7442:3;7438:20;7435:1;7428:31;7482:4;7479:1;7472:15;7510:4;7507:1;7500:15;7364:161;;7151:380;;;:::o;7883:127::-;7944:10;7939:3;7935:20;7932:1;7925:31;7975:4;7972:1;7965:15;7999:4;7996:1;7989:15;8015:168;8088:9;;;8119;;8136:15;;;8130:22;;8116:37;8106:71;;8157:18;;:::i;8533:125::-;8598:9;;;8619:10;;;8616:36;;;8632:18;;:::i;9019:331::-;9221:2;9203:21;;;9260:1;9240:18;;;9233:29;-1:-1:-1;;;9293:2:1;9278:18;;9271:38;9341:2;9326:18;;9019:331::o;9355:128::-;9422:9;;;9443:11;;;9440:37;;;9457:18;;:::i;9488:135::-;9527:3;9548:17;;;9545:43;;9568:18;;:::i;:::-;-1:-1:-1;9615:1:1;9604:13;;9488:135::o;9628:127::-;9689:10;9684:3;9680:20;9677:1;9670:31;9720:4;9717:1;9710:15;9744:4;9741:1;9734:15;9760:496;9939:3;9977:6;9971:13;9993:66;10052:6;10047:3;10040:4;10032:6;10028:17;9993:66;:::i;:::-;10122:13;;10081:16;;;;10144:70;10122:13;10081:16;10191:4;10179:17;;10144:70;:::i;:::-;10230:20;;9760:496;-1:-1:-1;;;;9760:496:1:o;13118:489::-;-1:-1:-1;;;;;13387:15:1;;;13369:34;;13439:15;;13434:2;13419:18;;13412:43;13486:2;13471:18;;13464:34;;;13534:3;13529:2;13514:18;;13507:31;;;13312:4;;13555:46;;13581:19;;13573:6;13555:46;:::i;:::-;13547:54;13118:489;-1:-1:-1;;;;;;13118:489:1:o;13612:249::-;13681:6;13734:2;13722:9;13713:7;13709:23;13705:32;13702:52;;;13750:1;13747;13740:12;13702:52;13782:9;13776:16;13801:30;13825:5;13801:30;:::i;13998:127::-;14059:10;14054:3;14050:20;14047:1;14040:31;14090:4;14087:1;14080:15;14114:4;14111:1;14104:15

Swarm Source

ipfs://9617233427a95e1bf1ed9b65ea07b4221a5a1d8101bc250672cfc7e4e9571364

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