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
Balance
2 ArcanaLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
ArcanaFlightPass
Compiler Version
v0.8.19+commit.7dd6d404
Contract Source Code (Solidity)
/** *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
[{"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
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
Deployed Bytecode
0x60806040526004361061020f5760003560e01c8063715018a611610118578063c1f26123116100a0578063d304c4bc1161006f578063d304c4bc146105fb578063ddc156a314610610578063e985e9c514610623578063ed5652341461066c578063f2fde38b1461067f57600080fd5b8063c1f2612314610585578063c285e107146105a5578063c87b56dd146105bb578063cbf1b53e146105db57600080fd5b8063a51312c8116100e7578063a51312c8146104e3578063b717d3ff14610503578063b88d4fde14610524578063b90306ad14610544578063bcc9ca5b1461056457600080fd5b8063715018a61461047b5780638da5cb5b1461049057806395d89b41146104ae578063a22cb465146104c357600080fd5b80632848aeaf1161019b57806342842e0e1161016a57806342842e0e146103e05780636352211e146104005780636447c35d146104205780636817c76c1461044057806370a082311461045b57600080fd5b80632848aeaf146103685780632db11544146103985780632f48de79146103ab5780633ccfd60b146103cb57600080fd5b8063085c9bac116101e2578063085c9bac146102cc578063095ea7b3146102ed5780630cb61f6c1461030f57806318160ddd1461032f57806323b872dd1461034857600080fd5b806301ffc9a71461021457806304d1b3191461024957806306fdde0314610272578063081812fc14610294575b600080fd5b34801561022057600080fd5b5061023461022f366004611f06565b61069f565b60405190151581526020015b60405180910390f35b34801561025557600080fd5b50610264667fe5cf2bea000081565b604051908152602001610240565b34801561027e57600080fd5b506102876106f1565b6040516102409190611f73565b3480156102a057600080fd5b506102b46102af366004611f86565b610783565b6040516001600160a01b039091168152602001610240565b3480156102d857600080fd5b5060095461023490600160a81b900460ff1681565b3480156102f957600080fd5b5061030d610308366004611fbb565b6107c7565b005b34801561031b57600080fd5b506009546102b4906001600160a01b031681565b34801561033b57600080fd5b5060015460005403610264565b34801561035457600080fd5b5061030d610363366004611fe5565b610854565b34801561037457600080fd5b50610234610383366004612021565b600a6020526000908152604090205460ff1681565b61030d6103a6366004611f86565b61085f565b3480156103b757600080fd5b5061030d6103c636600461204c565b6109fd565b3480156103d757600080fd5b5061030d610a39565b3480156103ec57600080fd5b5061030d6103fb366004611fe5565b610a4f565b34801561040c57600080fd5b506102b461041b366004611f86565b610a6a565b34801561042c57600080fd5b5061030d61043b36600461207f565b610a7c565b34801561044c57600080fd5b50610264666a94d74f43000081565b34801561046757600080fd5b50610264610476366004612021565b610af6565b34801561048757600080fd5b5061030d610b44565b34801561049c57600080fd5b506008546001600160a01b03166102b4565b3480156104ba57600080fd5b50610287610b58565b3480156104cf57600080fd5b5061030d6104de3660046120f3565b610b67565b3480156104ef57600080fd5b5061030d6104fe36600461207f565b610bfc565b34801561050f57600080fd5b5060095461023490600160b01b900460ff1681565b34801561053057600080fd5b5061030d61053f366004612125565b610c76565b34801561055057600080fd5b5061030d61055f366004611f86565b610cc7565b34801561057057600080fd5b5060095461023490600160a01b900460ff1681565b34801561059157600080fd5b5061030d6105a0366004611f86565b610cda565b3480156105b157600080fd5b506102646115b381565b3480156105c757600080fd5b506102876105d6366004611f86565b610d50565b3480156105e757600080fd5b506102b46105f6366004612241565b610dd4565b34801561060757600080fd5b50610264600281565b34801561061c57600080fd5b5033610264565b34801561062f57600080fd5b5061023461063e366004612282565b6001600160a01b03918216600090815260076020908152604080832093909416825291909152205460ff1690565b61030d61067a3660046122ac565b610e6c565b34801561068b57600080fd5b5061030d61069a366004612021565b6110ca565b60006001600160e01b031982166380ac58cd60e01b14806106d057506001600160e01b03198216635b5e139f60e01b145b806106eb57506301ffc9a760e01b6001600160e01b03198316145b92915050565b606060028054610700906122f7565b80601f016020809104026020016040519081016040528092919081815260200182805461072c906122f7565b80156107795780601f1061074e57610100808354040283529160200191610779565b820191906000526020600020905b81548152906001019060200180831161075c57829003601f168201915b5050505050905090565b600061078e82611140565b6107ab576040516333d1c03960e21b815260040160405180910390fd5b506000908152600660205260409020546001600160a01b031690565b60006107d282610a6a565b9050806001600160a01b0316836001600160a01b0316036108065760405163250fdee360e21b815260040160405180910390fd5b336001600160a01b038216148015906108265750610824813361063e565b155b15610844576040516367d9dca160e11b815260040160405180910390fd5b61084f83838361116b565b505050565b61084f8383836111c7565b600954600160a01b900460ff166108b25760405162461bcd60e51b8152602060048201526012602482015271141d589b1a58c8135a5b9d0810db1bdcd95960721b60448201526064015b60405180910390fd5b6108c3667fe5cf2bea000082612347565b3410156109055760405162461bcd60e51b815260206004820152601060248201526f4e6f7420656e6f7567682066756e647360801b60448201526064016108a9565b6109116002600361235e565b336000908152600560205260409020548290600160401b90046001600160401b031661093d919061235e565b111561098b5760405162461bcd60e51b815260206004820152601b60248201527f596f75207265616368656420796f7572204d696e74206c696d6974000000000060448201526064016108a9565b6115b38161099860005490565b6109a2919061235e565b11156109c05760405162461bcd60e51b81526004016108a990612371565b6109ca33826113a3565b6000816000546109da9190612393565b90505b6000548110156109f957806109f1816123a6565b9150506109dd565b5050565b610a056113bd565b6009805461ffff60a01b1916600160a01b9315159390930260ff60a81b191692909217600160a81b91151591909102179055565b610a416113bd565b47610a4c3382611417565b50565b61084f83838360405180602001604052806000815250610c76565b6000610a7582611530565b5192915050565b610a846113bd565b60005b8181101561084f576001600a6000858585818110610aa757610aa76123bf565b9050602002016020810190610abc9190612021565b6001600160a01b031681526020810191909152604001600020805460ff191691151591909117905580610aee816123a6565b915050610a87565b60006001600160a01b038216610b1f576040516323d3ad8160e21b815260040160405180910390fd5b506001600160a01b03166000908152600560205260409020546001600160401b031690565b610b4c6113bd565b610b56600061164a565b565b606060038054610700906122f7565b336001600160a01b03831603610b905760405163b06307db60e01b815260040160405180910390fd5b3360008181526007602090815260408083206001600160a01b03871680855290835292819020805460ff191686151590811790915590519081529192917f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a35050565b610c046113bd565b60005b8181101561084f576000600a6000858585818110610c2757610c276123bf565b9050602002016020810190610c3c9190612021565b6001600160a01b031681526020810191909152604001600020805460ff191691151591909117905580610c6e816123a6565b915050610c07565b610c818484846111c7565b6001600160a01b0383163b15158015610ca35750610ca18484848461169c565b155b15610cc1576040516368d2bf6b60e11b815260040160405180910390fd5b50505050565b610ccf6113bd565b610a4c816000611787565b610ce26113bd565b6115b381610cef60005490565b610cf9919061235e565b1115610d175760405162461bcd60e51b81526004016108a990612371565b610d2133826113a3565b600081600054610d319190612393565b90505b6000548110156109f95780610d48816123a6565b915050610d34565b6060610d5b82611140565b610d7857604051630a14c4b560e41b815260040160405180910390fd5b6000610d8261193a565b90508051600003610da25760405180602001604052806000815250610dcd565b80610dac8461195a565b604051602001610dbd9291906123d5565b6040516020818303038152906040525b9392505050565b6000610dcd83838080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250506040517f19457468657265756d205369676e6564204d6573736167653a0a333200000000602082015233603c820152605c019150610e489050565b604051602081830303815290604052805190602001206119ec90919063ffffffff16565b600954600160a81b900460ff16610ebd5760405162461bcd60e51b8152602060048201526015602482015274105b1b1bdddb1a5cdd08135a5b9d0810db1bdcd959605a1b60448201526064016108a9565b610ece666a94d74f43000084612347565b341015610f105760405162461bcd60e51b815260206004820152601060248201526f4e6f7420656e6f7567682066756e647360801b60448201526064016108a9565b336000908152600560205260409020546002908490600160401b90046001600160401b0316610f3f919061235e565b1115610f8d5760405162461bcd60e51b815260206004820152601b60248201527f596f75207265616368656420796f7572204d696e74206c696d6974000000000060448201526064016108a9565b6115b383610f9a60005490565b610fa4919061235e565b1115610fc25760405162461bcd60e51b81526004016108a990612371565b61103482828080601f016020809104026020016040519081016040528093929190818152602001838380828437600092019190915250506040517f19457468657265756d205369676e6564204d6573736167653a0a333200000000602082015233603c820152605c019150610e489050565b600c546001600160a01b039081169116146110915760405162461bcd60e51b815260206004820152601e60248201527f596f7520617265206e6f74206f6e2074686520616c6c6f77206c6973742e000060448201526064016108a9565b61109b33846113a3565b6000836000546110ab9190612393565b90505b600054811015610cc157806110c2816123a6565b9150506110ae565b6110d26113bd565b6001600160a01b0381166111375760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016108a9565b610a4c8161164a565b60008054821080156106eb575050600090815260046020526040902054600160e01b900460ff161590565b60008281526006602052604080822080546001600160a01b0319166001600160a01b0387811691821790925591518593918516917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92591a4505050565b60006111d282611530565b9050836001600160a01b031681600001516001600160a01b0316146112095760405162a1148160e81b815260040160405180910390fd5b6000336001600160a01b03861614806112275750611227853361063e565b8061124257503361123784610783565b6001600160a01b0316145b90508061126257604051632ce44b5f60e11b815260040160405180910390fd5b6001600160a01b03841661128957604051633a954ecd60e21b815260040160405180910390fd5b6112956000848761116b565b6001600160a01b038581166000908152600560209081526040808320805467ffffffffffffffff198082166001600160401b0392831660001901831617909255898616808652838620805493841693831660019081018416949094179055898652600490945282852080546001600160e01b031916909417600160a01b4290921691909102178355870180845292208054919390911661136957600054821461136957805460208601516001600160401b0316600160a01b026001600160e01b03199091166001600160a01b038a16171781555b50505082846001600160a01b0316866001600160a01b03166000805160206124ab83398151915260405160405180910390a45b5050505050565b6109f9828260405180602001604052806000815250611a10565b6008546001600160a01b03163314610b565760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108a9565b804710156114675760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a20696e73756666696369656e742062616c616e636500000060448201526064016108a9565b6000826001600160a01b03168260405160006040518083038185875af1925050503d80600081146114b4576040519150601f19603f3d011682016040523d82523d6000602084013e6114b9565b606091505b505090508061084f5760405162461bcd60e51b815260206004820152603a60248201527f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260448201527f6563697069656e74206d6179206861766520726576657274656400000000000060648201526084016108a9565b60408051606081018252600080825260208201819052918101919091528160005481101561163157600081815260046020908152604091829020825160608101845290546001600160a01b0381168252600160a01b81046001600160401b031692820192909252600160e01b90910460ff1615159181018290529061162f5780516001600160a01b0316156115c6579392505050565b5060001901600081815260046020908152604091829020825160608101845290546001600160a01b038116808352600160a01b82046001600160401b031693830193909352600160e01b900460ff161515928101929092521561162a579392505050565b6115c6565b505b604051636f96cda160e11b815260040160405180910390fd5b600880546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b604051630a85bd0160e11b81526000906001600160a01b0385169063150b7a02906116d1903390899088908890600401612404565b6020604051808303816000875af192505050801561170c575060408051601f3d908101601f1916820190925261170991810190612441565b60015b61176a573d80801561173a576040519150601f19603f3d011682016040523d82523d6000602084013e61173f565b606091505b508051600003611762576040516368d2bf6b60e11b815260040160405180910390fd5b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050949350505050565b600061179283611530565b805190915082156117f8576000336001600160a01b03831614806117bb57506117bb823361063e565b806117d65750336117cb86610783565b6001600160a01b0316145b9050806117f657604051632ce44b5f60e11b815260040160405180910390fd5b505b6118046000858361116b565b6001600160a01b0380821660008181526005602090815260408083208054600160801b6000196001600160401b0380841691909101811667ffffffffffffffff198416811783900482166001908101831690930277ffffffffffffffff0000000000000000ffffffffffffffff19909416179290921783558b86526004909452828520805460ff60e01b1942909316600160a01b026001600160e01b03199091169097179690961716600160e01b17855591890180845292208054919490911661190257600054821461190257805460208701516001600160401b0316600160a01b026001600160e01b03199091166001600160a01b038716171781555b5050604051869250600091506001600160a01b038416906000805160206124ab833981519152908390a4505060018054810190555050565b606060405180606001604052806036815260200161247560369139905090565b6060600061196783611a1d565b60010190506000816001600160401b038111156119865761198661210f565b6040519080825280601f01601f1916602001820160405280156119b0576020820181803683370190505b5090508181016020015b600019016f181899199a1a9b1b9c1cb0b131b232b360811b600a86061a8153600a85049450846119ba57509392505050565b60008060006119fb8585611af5565b91509150611a0881611b3a565b509392505050565b61084f8383836001611c84565b60008072184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b8310611a5c5772184f03e93ff9f4daa797ed6e38ed64bf6a1f0160401b830492506040015b6d04ee2d6d415b85acef81000000008310611a88576d04ee2d6d415b85acef8100000000830492506020015b662386f26fc100008310611aa657662386f26fc10000830492506010015b6305f5e1008310611abe576305f5e100830492506008015b6127108310611ad257612710830492506004015b60648310611ae4576064830492506002015b600a83106106eb5760010192915050565b6000808251604103611b2b5760208301516040840151606085015160001a611b1f87828585611e2c565b94509450505050611b33565b506000905060025b9250929050565b6000816004811115611b4e57611b4e61245e565b03611b565750565b6001816004811115611b6a57611b6a61245e565b03611bb75760405162461bcd60e51b815260206004820152601860248201527f45434453413a20696e76616c6964207369676e6174757265000000000000000060448201526064016108a9565b6002816004811115611bcb57611bcb61245e565b03611c185760405162461bcd60e51b815260206004820152601f60248201527f45434453413a20696e76616c6964207369676e6174757265206c656e6774680060448201526064016108a9565b6003816004811115611c2c57611c2c61245e565b03610a4c5760405162461bcd60e51b815260206004820152602260248201527f45434453413a20696e76616c6964207369676e6174757265202773272076616c604482015261756560f01b60648201526084016108a9565b6000546001600160a01b038516611cad57604051622e076360e81b815260040160405180910390fd5b83600003611cce5760405163b562e8dd60e01b815260040160405180910390fd5b6001600160a01b038516600081815260056020908152604080832080546fffffffffffffffffffffffffffffffff1981166001600160401b038083168c018116918217600160401b67ffffffffffffffff1990941690921783900481168c01811690920217909155858452600490925290912080546001600160e01b031916909217600160a01b429092169190910217905580808501838015611d7a57506001600160a01b0387163b15155b15611df0575b60405182906001600160a01b038916906000906000805160206124ab833981519152908290a4611db9600088848060010195508861169c565b611dd6576040516368d2bf6b60e11b815260040160405180910390fd5b808203611d80578260005414611deb57600080fd5b611e23565b5b6040516001830192906001600160a01b038916906000906000805160206124ab833981519152908290a4808203611df1575b5060005561139c565b6000807f7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0831115611e635750600090506003611ee7565b6040805160008082526020820180845289905260ff881692820192909252606081018690526080810185905260019060a0016020604051602081039080840390855afa158015611eb7573d6000803e3d6000fd5b5050604051601f1901519150506001600160a01b038116611ee057600060019250925050611ee7565b9150600090505b94509492505050565b6001600160e01b031981168114610a4c57600080fd5b600060208284031215611f1857600080fd5b8135610dcd81611ef0565b60005b83811015611f3e578181015183820152602001611f26565b50506000910152565b60008151808452611f5f816020860160208601611f23565b601f01601f19169290920160200192915050565b602081526000610dcd6020830184611f47565b600060208284031215611f9857600080fd5b5035919050565b80356001600160a01b0381168114611fb657600080fd5b919050565b60008060408385031215611fce57600080fd5b611fd783611f9f565b946020939093013593505050565b600080600060608486031215611ffa57600080fd5b61200384611f9f565b925061201160208501611f9f565b9150604084013590509250925092565b60006020828403121561203357600080fd5b610dcd82611f9f565b80358015158114611fb657600080fd5b6000806040838503121561205f57600080fd5b6120688361203c565b91506120766020840161203c565b90509250929050565b6000806020838503121561209257600080fd5b82356001600160401b03808211156120a957600080fd5b818501915085601f8301126120bd57600080fd5b8135818111156120cc57600080fd5b8660208260051b85010111156120e157600080fd5b60209290920196919550909350505050565b6000806040838503121561210657600080fd5b61206883611f9f565b634e487b7160e01b600052604160045260246000fd5b6000806000806080858703121561213b57600080fd5b61214485611f9f565b935061215260208601611f9f565b92506040850135915060608501356001600160401b038082111561217557600080fd5b818701915087601f83011261218957600080fd5b81358181111561219b5761219b61210f565b604051601f8201601f19908116603f011681019083821181831017156121c3576121c361210f565b816040528281528a60208487010111156121dc57600080fd5b82602086016020830137600060208483010152809550505050505092959194509250565b60008083601f84011261221257600080fd5b5081356001600160401b0381111561222957600080fd5b602083019150836020828501011115611b3357600080fd5b6000806020838503121561225457600080fd5b82356001600160401b0381111561226a57600080fd5b61227685828601612200565b90969095509350505050565b6000806040838503121561229557600080fd5b61229e83611f9f565b915061207660208401611f9f565b6000806000604084860312156122c157600080fd5b8335925060208401356001600160401b038111156122de57600080fd5b6122ea86828701612200565b9497909650939450505050565b600181811c9082168061230b57607f821691505b60208210810361232b57634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052601160045260246000fd5b80820281158282048414176106eb576106eb612331565b808201808211156106eb576106eb612331565b60208082526008908201526714d3d3110813d55560c21b604082015260600190565b818103818111156106eb576106eb612331565b6000600182016123b8576123b8612331565b5060010190565b634e487b7160e01b600052603260045260246000fd5b600083516123e7818460208801611f23565b8351908301906123fb818360208801611f23565b01949350505050565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061243790830184611f47565b9695505050505050565b60006020828403121561245357600080fd5b8151610dcd81611ef0565b634e487b7160e01b600052602160045260246000fdfe697066733a2f2f516d574277687768384c4d756846314a6d756875786b706d52656a734358574e39385332425850464163364e6d7a2fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3efa26469706673582212209617233427a95e1bf1ed9b65ea07b4221a5a1d8101bc250672cfc7e4e957136464736f6c63430008130033
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
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
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.