Token Deevy
Overview ERC-721
Total Supply:
2,185 DEEVY
Holders:
2,064 addresses
Contract:
Balance
1 DEEVY
[ Download CSV Export ]
[ Download CSV Export ]
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
Deevy
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Arbiscan.io on 2021-09-10 */ ////// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <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); } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.2 <0.8.0; ////import "../../introspection/IERC165.sol"; /** * @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`, 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 be 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: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * 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 Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @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 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); /** * @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; } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <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 GSN 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 payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev String operations. */ library Strings { /** * @dev Converts a `uint256` to its ASCII `string` representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); uint256 index = digits - 1; temp = value; while (temp != 0) { buffer[index--] = bytes1(uint8(48 + temp % 10)); temp /= 10; } return string(buffer); } } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Library for managing an enumerable variant of Solidity's * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`] * type. * * Maps have the following properties: * * - Entries are added, removed, and checked for existence in constant time * (O(1)). * - Entries are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableMap for EnumerableMap.UintToAddressMap; * * // Declare a set state variable * EnumerableMap.UintToAddressMap private myMap; * } * ``` * * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are * supported. */ library EnumerableMap { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Map type with // bytes32 keys and values. // The Map implementation uses private functions, and user-facing // implementations (such as Uint256ToAddressMap) are just wrappers around // the underlying Map. // This means that we can only create new EnumerableMaps for types that fit // in bytes32. struct MapEntry { bytes32 _key; bytes32 _value; } struct Map { // Storage of map keys and values MapEntry[] _entries; // Position of the entry defined by a key in the `entries` array, plus 1 // because index 0 means a key is not in the map. mapping (bytes32 => uint256) _indexes; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) { // Equivalent to !contains(map, key) map._entries.push(MapEntry({ _key: key, _value: value })); // The entry is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value map._indexes[key] = map._entries.length; return true; } else { map._entries[keyIndex - 1]._value = value; return false; } } /** * @dev Removes a key-value pair from a map. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function _remove(Map storage map, bytes32 key) private returns (bool) { // We read and store the key's index to prevent multiple reads from the same storage slot uint256 keyIndex = map._indexes[key]; if (keyIndex != 0) { // Equivalent to contains(map, key) // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one // in the array, and then remove the last entry (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = keyIndex - 1; uint256 lastIndex = map._entries.length - 1; // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. MapEntry storage lastEntry = map._entries[lastIndex]; // Move the last entry to the index where the entry to delete is map._entries[toDeleteIndex] = lastEntry; // Update the index for the moved entry map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved entry was stored map._entries.pop(); // Delete the index for the deleted slot delete map._indexes[key]; return true; } else { return false; } } /** * @dev Returns true if the key is in the map. O(1). */ function _contains(Map storage map, bytes32 key) private view returns (bool) { return map._indexes[key] != 0; } /** * @dev Returns the number of key-value pairs in the map. O(1). */ function _length(Map storage map) private view returns (uint256) { return map._entries.length; } /** * @dev Returns the key-value pair stored at position `index` in the map. O(1). * * Note that there are no guarantees on the ordering of entries inside the * array, and it may change when more entries are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) { require(map._entries.length > index, "EnumerableMap: index out of bounds"); MapEntry storage entry = map._entries[index]; return (entry._key, entry._value); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. */ function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) { uint256 keyIndex = map._indexes[key]; if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key) return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function _get(Map storage map, bytes32 key) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } /** * @dev Same as {_get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {_tryGet}. */ function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) { uint256 keyIndex = map._indexes[key]; require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key) return map._entries[keyIndex - 1]._value; // All indexes are 1-based } // UintToAddressMap struct UintToAddressMap { Map _inner; } /** * @dev Adds a key-value pair to a map, or updates the value for an existing * key. O(1). * * Returns true if the key was added to the map, that is if it was not * already present. */ function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) { return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the key was removed from the map, that is if it was present. */ function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) { return _remove(map._inner, bytes32(key)); } /** * @dev Returns true if the key is in the map. O(1). */ function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) { return _contains(map._inner, bytes32(key)); } /** * @dev Returns the number of elements in the map. O(1). */ function length(UintToAddressMap storage map) internal view returns (uint256) { return _length(map._inner); } /** * @dev Returns the element stored at position `index` in the set. O(1). * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) { (bytes32 key, bytes32 value) = _at(map._inner, index); return (uint256(key), address(uint160(uint256(value)))); } /** * @dev Tries to returns the value associated with `key`. O(1). * Does not revert if `key` is not in the map. * * _Available since v3.4._ */ function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) { (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key)); return (success, address(uint160(uint256(value)))); } /** * @dev Returns the value associated with `key`. O(1). * * Requirements: * * - `key` must be in the map. */ function get(UintToAddressMap storage map, uint256 key) internal view returns (address) { return address(uint160(uint256(_get(map._inner, bytes32(key))))); } /** * @dev Same as {get}, with a custom error message when `key` is not in the map. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryGet}. */ function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) { return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage)))); } } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping (bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.2 <0.8.0; /** * @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 * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 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"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (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 functionCall(target, data, "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"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(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) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(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) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // 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 // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <0.8.0; ////import "./IERC165.sol"; /** * @dev Implementation of the {IERC165} interface. * * Contracts may inherit from this and call {_registerInterface} to declare * their support of an interface. */ abstract contract ERC165 is IERC165 { /* * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 */ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; /** * @dev Mapping of interface ids to whether or not it's supported. */ mapping(bytes4 => bool) private _supportedInterfaces; constructor () internal { // Derived contracts need only register support for their own interfaces, // we register support for ERC165 itself here _registerInterface(_INTERFACE_ID_ERC165); } /** * @dev See {IERC165-supportsInterface}. * * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return _supportedInterfaces[interfaceId]; } /** * @dev Registers the contract as an implementer of the interface defined by * `interfaceId`. Support of the actual ERC165 interface is automatic and * registering its interface id is not required. * * See {IERC165-supportsInterface}. * * Requirements: * * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`). */ function _registerInterface(bytes4 interfaceId) internal virtual { require(interfaceId != 0xffffffff, "ERC165: invalid interface id"); _supportedInterfaces[interfaceId] = true; } } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <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 `IERC721.onERC721Received.selector`. */ function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4); } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.2 <0.8.0; ////import "./IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.2 <0.8.0; ////import "./IERC721.sol"; /** * @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); } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <0.8.0; ////import "../utils/Context.sol"; ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <0.8.0; ////import "../utils/Context.sol"; /** * @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 () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { 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 { emit OwnershipTransferred(_owner, address(0)); _owner = 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"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity 0.6.12; ////import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol"; interface ILoot is IERC721 { function getWeapon(uint256 tokenId) external view returns (string memory); function getChest(uint256 tokenId) external view returns (string memory); function getHead(uint256 tokenId) external view returns (string memory); function getWaist(uint256 tokenId) external view returns (string memory); function getFoot(uint256 tokenId) external view returns (string memory); function getHand(uint256 tokenId) external view returns (string memory); function getNeck(uint256 tokenId) external view returns (string memory); function getRing(uint256 tokenId) external view returns (string memory); function tokenUri(uint256 tokenId) external view returns (string memory); } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity 0.6.12; interface IDeevySet { function tokenURI(uint256 tokenId) external view returns (string memory); function name() external view returns (string memory); function symbol() external view returns (string memory); } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity 0.6.12; ////import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol"; interface IDeevy is IERC721 { function warpLoot(address account, uint256 tokenId) external; function claim(address account, uint256 tokenId) external; function ownerClaim(uint256 tokenId) external; } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT // Copied from https://raw.githubusercontent.com/OpenZeppelin/openzeppelin-contracts/release-v3.1.0/contracts/token/ERC721/ERC721.sol // It only changes the ////imports. pragma solidity ^0.6.0; ////import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; ////import "@openzeppelin/contracts/GSN/Context.sol"; ////import "@openzeppelin/contracts/token/ERC721/IERC721.sol"; ////import "@openzeppelin/contracts/token/ERC721/IERC721Metadata.sol"; ////import "@openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol"; ////import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol"; ////import "@openzeppelin/contracts/introspection/ERC165.sol"; ////import "@openzeppelin/contracts/math/SafeMath.sol"; ////import "@openzeppelin/contracts/utils/Address.sol"; ////import "@openzeppelin/contracts/utils/EnumerableSet.sol"; ////import "@openzeppelin/contracts/utils/EnumerableMap.sol"; ////import "@openzeppelin/contracts/utils/Strings.sol"; /** * @title ERC721 Non-Fungible Token Standard basic implementation * @dev see https://eips.ethereum.org/EIPS/eip-721 */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable { using SafeMath for uint256; using Address for address; using EnumerableSet for EnumerableSet.UintSet; using EnumerableMap for EnumerableMap.UintToAddressMap; using Strings for uint256; // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector` bytes4 private constant _ERC721_RECEIVED = 0x150b7a02; // Mapping from holder address to their (enumerable) set of owned tokens mapping(address => EnumerableSet.UintSet) private _holderTokens; // Enumerable mapping from token ids to their owners EnumerableMap.UintToAddressMap private _tokenOwners; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; // Token name string private _name; // Token symbol string private _symbol; // Optional mapping for token URIs mapping(uint256 => string) private _tokenURIs; // Base URI string private _baseURI; /* * bytes4(keccak256('balanceOf(address)')) == 0x70a08231 * bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e * bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3 * bytes4(keccak256('getApproved(uint256)')) == 0x081812fc * bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465 * bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5 * bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd * bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e * bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde * * => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^ * 0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd */ bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd; /* * bytes4(keccak256('name()')) == 0x06fdde03 * bytes4(keccak256('symbol()')) == 0x95d89b41 * bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd * * => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f */ bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f; /* * bytes4(keccak256('totalSupply()')) == 0x18160ddd * bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59 * bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7 * * => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63 */ bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name, string memory symbol) public { _name = name; _symbol = symbol; // register the supported interfaces to conform to ERC721 via ERC165 _registerInterface(_INTERFACE_ID_ERC721); _registerInterface(_INTERFACE_ID_ERC721_METADATA); _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _holderTokens[owner].length(); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view override returns (address) { return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token"); } /** * @dev See {IERC721Metadata-name}. */ function name() public view override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; // If there is no base URI, return the token URI. if (bytes(_baseURI).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(_baseURI, _tokenURI)); } // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI. return string(abi.encodePacked(_baseURI, tokenId.toString())); } /** * @dev Returns the base URI set via {_setBaseURI}. This will be * automatically added as a prefix in {tokenURI} to each token's URI, or * to the token ID if no specific URI is set for that token ID. */ function baseURI() public view returns (string memory) { return _baseURI; } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) { return _holderTokens[owner].at(index); } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view override returns (uint256) { // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds return _tokenOwners.length(); } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view override returns (uint256) { (uint256 tokenId, ) = _tokenOwners.at(index); return tokenId; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved" ); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public virtual override { require( _isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved" ); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mecanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory _data ) internal virtual { _transfer(from, to, tokenId); require( _checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view returns (bool) { return _tokenOwners.contains(tokenId); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: d* * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory _data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); // Clear metadata (if any) if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } _holderTokens[owner].remove(tokenId); _tokenOwners.remove(tokenId); emit Transfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _holderTokens[from].remove(tokenId); _holderTokens[to].add(tokenId); _tokenOwners.set(tokenId, to); emit Transfer(from, to, tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @dev Internal function to set the base URI for all token IDs. It is * automatically added as a prefix to the value returned in {tokenURI}, * or to the token ID if {tokenURI} is empty. */ function _setBaseURI(string memory baseURI_) internal virtual { _baseURI = baseURI_; } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { if (!to.isContract()) { return true; } bytes memory returndata = to.functionCall( abi.encodeWithSelector( IERC721Receiver(to).onERC721Received.selector, _msgSender(), from, tokenId, _data ), "ERC721: transfer to non ERC721Receiver implementer" ); bytes4 retval = abi.decode(returndata, (bytes4)); return (retval == _ERC721_RECEIVED); } function _approve(address to, uint256 tokenId) private { _tokenApprovals[tokenId] = to; emit Approval(ownerOf(tokenId), to, tokenId); } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * 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, ``from``'s `tokenId` will be burned. * - `from` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () internal { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } ////// SPDX-License-Identifier-FLATTEN-SUPPRESS-WARNING: MIT pragma experimental ABIEncoderV2; pragma solidity 0.6.12; ////import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol"; ////import { ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol"; ////import "./tokens/ERC721.sol"; ////import {IDeevy} from "./IDeevy.sol"; ////import {IDeevySet} from "./IDeevySet.sol"; ////import {ILoot} from "./ILoot.sol"; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { /** * @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; } } contract Deevy is ERC721, ReentrancyGuard, Ownable, IDeevy { struct DeevySet { address set; uint256 start; uint256 end; bool exists; } address public bridgeMinter; address public minter; // reference readonly copy of Loot contract in L2 address public loot; uint256 public LOOT_SUPPLY = 7779; // stores set information mapping(uint256 => DeevySet) public sets; // unique sets mapping(address => bool) public setAddresses; // unique set names mapping(bytes32 => bool) public setNames; // array for holding sets max mint uint256[] setsMax; // EVENTS event NewSet( address indexed _set, string _name, uint256 _start, uint256 _end ); constructor(address _minterAddress, address _bridgeMinter, address _warpedLoot) public ERC721("Deevy", "DEEVY") Ownable() { minter = _minterAddress; bridgeMinter = _bridgeMinter; loot = _warpedLoot; } function setMinter(address _newMinterAddress) external onlyOwner { minter = _newMinterAddress; } function setBridgeMinter(address _bridgeMinter) external onlyOwner { bridgeMinter = _bridgeMinter; } function addSet(address _set, uint256 _end) external onlyOwner { require(!setAddresses[_set], "!SET_ALREADY_USED"); setAddresses[_set] = true; DeevySet memory newSet; string memory setName = IDeevySet(_set).name(); bytes32 setHash = keccak256(abi.encodePacked(setName)); // first set if (setsMax.length == 0) { require(_end >= LOOT_SUPPLY, "!SUPPLY_FIRST_SET"); newSet = DeevySet({set: _set, start: 0, end: _end, exists: true}); sets[0] = newSet; setsMax.push(_end); setNames[setHash] = true; emit NewSet(_set, setName, 0, _end); return; } require(!setNames[setHash], "!SET_NAME_EXISTS"); // adding a new set DeevySet memory lastSet = sets[setsMax.length - 1]; require(_end > lastSet.end + 1, "!NEW_SET_START"); newSet = DeevySet({ set: _set, start: lastSet.end + 1, end: _end, exists: true }); setsMax.push(_end); sets[setsMax.length - 1] = newSet; setNames[setHash] = true; emit NewSet(_set, setName, newSet.start, newSet.end); } // exclusive claim function for loot holders function warpLoot(address account, uint256 tokenId) external override nonReentrant { require(bridgeMinter == msg.sender, "!BRIDGE_MINTER"); require(tokenId > 0 && tokenId < 8000, "!TOKEN_ID"); _safeMint(account, tokenId); } // one time claim function ownerClaim(uint256 tokenId) public override nonReentrant onlyOwner { require(tokenId >= 8000 && tokenId < 8999, "!TOKEN_ID"); _safeMint(owner(), tokenId); } function claim(address account, uint256 tokenId) external override nonReentrant { require(minter == msg.sender, "!MINTER"); require(tokenId >= 9000, "!TOKEN_ID"); require(setsMax.length > 0, "SETS_REQUIRED"); require(tokenId <= setsMax[setsMax.length - 1], "TOKEN_ID_OUT_OF_RANGE"); _safeMint(account, tokenId); } // view functions function tokenURI(uint256 tokenId) public view override returns (string memory) { address setProperties = getSet(tokenId); return setProperties == address(0x0) ? "" : IDeevySet(setProperties).tokenURI(tokenId); } // based on OZ https://github.com/OpenZeppelin/openzeppelin-contracts/blob/b0cf6fbb7a70f31527f36579ad644e1cf12fdf4e/contracts/utils/Arrays.sol function findSetIndex(uint256[] memory array, uint256 element) internal pure returns (uint256) { // return max since array is empty or above max, so this number would not exist if (array.length == 0 || element > array[array.length - 1]) { return type(uint256).max; } uint256 low = 0; uint256 high = array.length; while (low < high) { uint256 mid = Math.average(low, high); // Note that mid will always be strictly less than high (i.e. it will be a valid array index) // because Math.average rounds down (it does integer division with truncation). if (array[mid] > element) { high = mid; } else { low = mid + 1; } } // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound. if (low > 0 && array[low - 1] == element) { return low - 1; } else { return low; } } function getSetInfo(uint256 tokenId) public view returns (DeevySet memory) { uint256 i = findSetIndex(setsMax, tokenId); DeevySet memory info = sets[i]; return info; } function getSet(uint256 tokenId) public view returns (address) { DeevySet memory info = getSetInfo(tokenId); return info.set; } function name(uint256 tokenId) public view returns (string memory) { address setProperties = getSet(tokenId); return IDeevySet(setProperties).name(); } function symbol(uint256 tokenId) public view returns (string memory) { address setProperties = getSet(tokenId); return IDeevySet(setProperties).symbol(); } // Loot compatibility functions function getWeapon(uint256 tokenId) public view returns (string memory) { if (tokenId > LOOT_SUPPLY) return ""; return ILoot(loot).getWeapon(tokenId); } function getChest(uint256 tokenId) public view returns (string memory) { if (tokenId > LOOT_SUPPLY) return ""; return ILoot(loot).getChest(tokenId); } function getHead(uint256 tokenId) public view returns (string memory) { if (tokenId > LOOT_SUPPLY) return ""; return ILoot(loot).getHead(tokenId); } function getWaist(uint256 tokenId) public view returns (string memory) { if (tokenId > LOOT_SUPPLY) return ""; return ILoot(loot).getWaist(tokenId); } function getFoot(uint256 tokenId) public view returns (string memory) { if (tokenId > LOOT_SUPPLY) return ""; return ILoot(loot).getFoot(tokenId); } function getHand(uint256 tokenId) public view returns (string memory) { if (tokenId > LOOT_SUPPLY) return ""; return ILoot(loot).getHand(tokenId); } function getNeck(uint256 tokenId) public view returns (string memory) { if (tokenId > LOOT_SUPPLY) return ""; return ILoot(loot).getNeck(tokenId); } function getRing(uint256 tokenId) public view returns (string memory) { if (tokenId > LOOT_SUPPLY) return ""; return ILoot(loot).getRing(tokenId); } function lootTokenURI(uint256 tokenId) public view returns (string memory) { if (tokenId > LOOT_SUPPLY) return ""; return ILoot(loot).tokenUri(tokenId); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_minterAddress","type":"address"},{"internalType":"address","name":"_bridgeMinter","type":"address"},{"internalType":"address","name":"_warpedLoot","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_set","type":"address"},{"indexed":false,"internalType":"string","name":"_name","type":"string"},{"indexed":false,"internalType":"uint256","name":"_start","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_end","type":"uint256"}],"name":"NewSet","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":[],"name":"LOOT_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_set","type":"address"},{"internalType":"uint256","name":"_end","type":"uint256"}],"name":"addSet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bridgeMinter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"claim","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":"uint256","name":"tokenId","type":"uint256"}],"name":"getChest","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getFoot","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getHand","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getHead","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getNeck","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getRing","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getSet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getSetInfo","outputs":[{"components":[{"internalType":"address","name":"set","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"},{"internalType":"bool","name":"exists","type":"bool"}],"internalType":"struct Deevy.DeevySet","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getWaist","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getWeapon","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"loot","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"lootTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"ownerClaim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"setAddresses","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_bridgeMinter","type":"address"}],"name":"setBridgeMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_newMinterAddress","type":"address"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"name":"setNames","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"sets","outputs":[{"internalType":"address","name":"set","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"},{"internalType":"bool","name":"exists","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"warpLoot","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ec2075a71c208f9a9219bd73d4b40053f0c84dd3
-----Decoded View---------------
Arg [0] : _minterAddress (address): 0x0000000000000000000000000000000000000000
Arg [1] : _bridgeMinter (address): 0x0000000000000000000000000000000000000000
Arg [2] : _warpedLoot (address): 0xEc2075a71c208F9A9219BD73d4B40053F0C84Dd3
-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [2] : 000000000000000000000000ec2075a71c208f9a9219bd73d4b40053f0c84dd3
Deployed ByteCode Sourcemap
73703:7528:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79206:174;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44005:150;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;76331:287::-;;;;;;:::i;:::-;;:::i;:::-;;56913:92;;;:::i;73925:21::-;;;:::i;:::-;;;;;;;:::i;59667:213::-;;;;;;:::i;:::-;;:::i;59197:404::-;;;;;;:::i;:::-;;:::i;75022:1251::-;;;;;;:::i;:::-;;:::i;80335:171::-;;;;;;:::i;:::-;;:::i;58691:203::-;;;:::i;:::-;;;;;;;:::i;60541:376::-;;;;;;:::i;:::-;;:::i;58420:195::-;;;;;;:::i;:::-;;:::i;60988:185::-;;;;;;:::i;:::-;;:::i;76649:229::-;;;;;;:::i;:::-;;:::i;81051:177::-;;;;;;:::i;:::-;;:::i;79388:178::-;;;;;;:::i;:::-;;:::i;58971:164::-;;;;;;:::i;:::-;;:::i;79048:150::-;;;;;;:::i;:::-;;:::i;74107:40::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;56677:169::-;;;;;;:::i;:::-;;:::i;80693:171::-;;;;;;:::i;:::-;;:::i;74034:33::-;;;:::i;58247:89::-;;;:::i;74250:40::-;;;;;;:::i;:::-;;:::i;56400:215::-;;;;;;:::i;:::-;;:::i;49468:148::-;;;:::i;74174:44::-;;;;;;:::i;:::-;;:::i;48817:87::-;;;:::i;57074:96::-;;;:::i;79975:171::-;;;;;;:::i;:::-;;:::i;74008:19::-;;;:::i;80154:173::-;;;;;;:::i;:::-;;:::i;74900:114::-;;;;;;:::i;:::-;;:::i;79611:175::-;;;;;;:::i;:::-;;:::i;59952:295::-;;;;;;:::i;:::-;;:::i;76886:395::-;;;;;;:::i;:::-;;:::i;61244:365::-;;;;;;:::i;:::-;;:::i;80872:171::-;;;;;;:::i;:::-;;:::i;77312:276::-;;;;;;:::i;:::-;;:::i;80514:171::-;;;;;;:::i;:::-;;:::i;78841:199::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;73891:27::-;;;:::i;60318:156::-;;;;;;:::i;:::-;;:::i;79794:173::-;;;;;;:::i;:::-;;:::i;49771:244::-;;;;;;:::i;:::-;;:::i;74782:110::-;;;;;;:::i;:::-;;:::i;79206:174::-;79258:13;79284:21;79308:15;79315:7;79308:6;:15::i;:::-;79284:39;;79351:13;-1:-1:-1;;;;;79341:29:0;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;79341:31:0;;;;;;;;;;;;:::i;:::-;79334:38;;;79206:174;;;;:::o;44005:150::-;-1:-1:-1;;;;;;44114:33:0;44090:4;44114:33;;;;;;;;;;;;;;44005:150::o;76331:287::-;71920:1;72526:7;;:19;;72518:63;;;;-1:-1:-1;;;72518:63:0;;;;;;;:::i;:::-;;;;;;;;;71920:1;72659:7;:18;76465:12:::1;::::0;-1:-1:-1;;;;;76465:12:0::1;76481:10;76465:26;76457:53;;;;-1:-1:-1::0;;;76457:53:0::1;;;;;;;:::i;:::-;76539:1;76529:7;:11;:29;;;;;76554:4;76544:7;:14;76529:29;76521:51;;;;-1:-1:-1::0;;;76521:51:0::1;;;;;;;:::i;:::-;76583:27;76593:7;76602;76583:9;:27::i;:::-;-1:-1:-1::0;;71876:1:0;72838:7;:22;76331:287::o;56913:92::-;56992:5;56985:12;;;;;;;;-1:-1:-1;;56985:12:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56959:13;;56985:12;;56992:5;;56985:12;;56992:5;56985:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56913:92;:::o;73925:21::-;;;-1:-1:-1;;;;;73925:21:0;;:::o;59667:213::-;59735:7;59763:16;59771:7;59763;:16::i;:::-;59755:73;;;;-1:-1:-1;;;59755:73:0;;;;;;;:::i;:::-;-1:-1:-1;59848:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;59848:24:0;;59667:213::o;59197:404::-;59278:13;59294:16;59302:7;59294;:16::i;:::-;59278:32;;59335:5;-1:-1:-1;;;;;59329:11:0;:2;-1:-1:-1;;;;;59329:11:0;;;59321:57;;;;-1:-1:-1;;;59321:57:0;;;;;;;:::i;:::-;59429:5;-1:-1:-1;;;;;59413:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;59413:21:0;;:62;;;;59438:37;59455:5;59462:12;:10;:12::i;59438:37::-;59391:168;;;;-1:-1:-1;;;59391:168:0;;;;;;;:::i;:::-;59572:21;59581:2;59585:7;59572:8;:21::i;:::-;59197:404;;;:::o;75022:1251::-;49048:12;:10;:12::i;:::-;-1:-1:-1;;;;;49037:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;49037:23:0;;49029:68;;;;-1:-1:-1;;;49029:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;75105:18:0;::::1;;::::0;;;:12:::1;:18;::::0;;;;;::::1;;75104:19;75096:49;;;;-1:-1:-1::0;;;75096:49:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;75156:18:0;::::1;;::::0;;;:12:::1;:18;::::0;;;;:25;;-1:-1:-1;;75156:25:0::1;75177:4;75156:25;::::0;;75192:22:::1;;:::i;:::-;75227:21;75261:4;-1:-1:-1::0;;;;;75251:20:0::1;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;75251:22:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;75227:46;;75284:15;75329:7;75312:25;;;;;;;;:::i;:::-;;::::0;;-1:-1:-1;;75312:25:0;;::::1;::::0;;;;;;75302:36;;75312:25:::1;75302:36:::0;;::::1;::::0;75375:7:::1;:14:::0;75302:36;;-1:-1:-1;75371:357:0::1;;75427:11;;75419:4;:19;;75411:49;;;;-1:-1:-1::0;;;75411:49:0::1;;;;;;;:::i;:::-;75484:56;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;75484:56:0;;::::1;::::0;;;-1:-1:-1;75484:56:0::1;::::0;;::::1;::::0;;;;;;;;;75534:4:::1;75484:56:::0;;;;;;75555:7;;;:4:::1;:7:::0;;:16;;:7;:16;;;;;::::1;-1:-1:-1::0;;;;;;75555:16:0;;::::1;;::::0;;;;;;;;;;;;;;;;::::1;;-1:-1:-1::0;;75555:16:0;;::::1;;::::0;;75586:7:::1;:18:::0;;;;::::1;::::0;;;;::::1;::::0;;;75619:17;;;:8:::1;:17:::0;;;;;;:24;;;;::::1;::::0;;::::1;::::0;;;75665:30;;75484:56;;-1:-1:-1;75665:30:0::1;::::0;::::1;::::0;75678:7;;75520:4;;75665:30:::1;:::i;:::-;;;;;;;;75710:7;;;;;75371:357;75749:17;::::0;;;:8:::1;:17;::::0;;;;;::::1;;75748:18;75740:47;;;;-1:-1:-1::0;;;75740:47:0::1;;;;;;;:::i;:::-;75829:23;;:::i;:::-;-1:-1:-1::0;75860:7:0::1;:14:::0;-1:-1:-1;;75860:18:0;75855:24:::1;::::0;;;:4:::1;:24;::::0;;;;;;;;75829:50;;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;;;75829:50:0::1;::::0;;75877:1:::1;75829:50:::0;;::::1;::::0;;;::::1;::::0;;;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;::::1;;;;::::0;;;;;75905:15:::1;75898:22:::0;::::1;75890:49;;;;-1:-1:-1::0;;;75890:49:0::1;;;;;;;:::i;:::-;75959:133;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;75959:133:0;;::::1;::::0;;;76014:11;;::::1;::::0;76028:1:::1;76014:15:::0;;::::1;75959:133;::::0;;::::1;::::0;;;;;;;;;;;;;;;76103:7:::1;:18:::0;;;;::::1;::::0;;;::::1;::::0;;;76137:14;-1:-1:-1;;76137:18:0;-1:-1:-1;76132:24:0;;;:4:::1;:24:::0;;;;;:33;;;;;::::1;-1:-1:-1::0;;;;;;76132:33:0;;::::1;::::0;;;::::1;::::0;;;;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;::::1;::::0;;;::::1;;-1:-1:-1::0;;76132:33:0;;::::1;;::::0;;76176:17;;;:8:::1;:17:::0;;;;;;;:24;;;;::::1;::::0;;::::1;::::0;;;76240:12;;76254:10;;76218:47;;75959:133;;-1:-1:-1;75959:133:0;76218:47:::1;::::0;::::1;::::0;76231:7;;76240:12;;76218:47:::1;:::i;:::-;;;;;;;;49108:1;;;;;75022:1251:::0;;:::o;80335:171::-;80390:13;80430:11;;80420:7;:21;80416:36;;;-1:-1:-1;80443:9:0;;;;;;;;;-1:-1:-1;80443:9:0;;;;80416:36;80476:4;;80470:28;;-1:-1:-1;;;80470:28:0;;-1:-1:-1;;;;;80476:4:0;;;;80470:19;;:28;;80490:7;;80470:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;80470:28:0;;;;;;;;;;;;:::i;:::-;80463:35;80335:171;-1:-1:-1;;80335:171:0:o;58691:203::-;58744:7;58865:21;:12;:19;:21::i;:::-;58858:28;;58691:203;:::o;60541:376::-;60750:41;60769:12;:10;:12::i;:::-;60783:7;60750:18;:41::i;:::-;60728:140;;;;-1:-1:-1;;;60728:140:0;;;;;;;:::i;:::-;60881:28;60891:4;60897:2;60901:7;60881:9;:28::i;58420:195::-;-1:-1:-1;;;;;58577:20:0;;58545:7;58577:20;;;:13;:20;;;;;:30;;58601:5;58577:23;:30::i;:::-;58570:37;58420:195;-1:-1:-1;;;58420:195:0:o;60988:185::-;61126:39;61143:4;61149:2;61153:7;61126:39;;;;;;;;;;;;:16;:39::i;76649:229::-;71920:1;72526:7;;:19;;72518:63;;;;-1:-1:-1;;;72518:63:0;;;;;;;:::i;:::-;71920:1;72659:7;:18;49048:12:::1;:10;:12::i;:::-;-1:-1:-1::0;;;;;49037:23:0::1;:7;:5;:7::i;:::-;-1:-1:-1::0;;;;;49037:23:0::1;;49029:68;;;;-1:-1:-1::0;;;49029:68:0::1;;;;;;;:::i;:::-;76796:4:::2;76785:7;:15;;:33;;;;;76814:4;76804:7;:14;76785:33;76777:55;;;;-1:-1:-1::0;;;76777:55:0::2;;;;;;;:::i;:::-;76843:27;76853:7;:5;:7::i;:::-;76862;76843:9;:27::i;:::-;-1:-1:-1::0;71876:1:0;72838:7;:22;76649:229::o;81051:177::-;81111:13;81151:11;;81141:7;:21;81137:36;;;-1:-1:-1;81164:9:0;;;;;;;;;-1:-1:-1;81164:9:0;;;;81137:36;81197:4;;81191:29;;-1:-1:-1;;;81191:29:0;;-1:-1:-1;;;;;81197:4:0;;;;81191:20;;:29;;81212:7;;81191:29;;;:::i;79388:178::-;79442:13;79468:21;79492:15;79499:7;79492:6;:15::i;:::-;79468:39;;79535:13;-1:-1:-1;;;;;79525:31:0;;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58971:164;59038:7;;59080:22;:12;59096:5;59080:15;:22::i;:::-;-1:-1:-1;59058:44:0;58971:164;-1:-1:-1;;;58971:164:0:o;79048:150::-;79102:7;79122:20;;:::i;:::-;79145:19;79156:7;79145:10;:19::i;:::-;79182:8;;79048:150;-1:-1:-1;;;79048:150:0:o;74107:40::-;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;74107:40:0;;;;;;;;;:::o;56677:169::-;56741:7;56768:70;56785:7;56768:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;80693:171::-;80748:13;80788:11;;80778:7;:21;80774:36;;;-1:-1:-1;80801:9:0;;;;;;;;;-1:-1:-1;80801:9:0;;;;80774:36;80834:4;;80828:28;;-1:-1:-1;;;80828:28:0;;-1:-1:-1;;;;;80834:4:0;;;;80828:19;;:28;;80848:7;;80828:28;;;:::i;74034:33::-;;;;:::o;58247:89::-;58320:8;58313:15;;;;;;;;-1:-1:-1;;58313:15:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58287:13;;58313:15;;58320:8;;58313:15;;58320:8;58313:15;;;;;;;;;;;;;;;;;;;;;;;;74250:40;;;;;;;;;;;;;;;:::o;56400:215::-;56464:7;-1:-1:-1;;;;;56492:19:0;;56484:74;;;;-1:-1:-1;;;56484:74:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;56578:20:0;;;;;;:13;:20;;;;;:29;;:27;:29::i;49468:148::-;49048:12;:10;:12::i;:::-;-1:-1:-1;;;;;49037:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;49037:23:0;;49029:68;;;;-1:-1:-1;;;49029:68:0;;;;;;;:::i;:::-;49559:6:::1;::::0;49538:40:::1;::::0;49575:1:::1;::::0;-1:-1:-1;;;;;49559:6:0::1;::::0;49538:40:::1;::::0;49575:1;;49538:40:::1;49589:6;:19:::0;;-1:-1:-1;;;;;;49589:19:0::1;::::0;;49468:148::o;74174:44::-;;;;;;;;;;;;;;;:::o;48817:87::-;48890:6;;-1:-1:-1;;;;;48890:6:0;48817:87;:::o;57074:96::-;57155:7;57148:14;;;;;;;;-1:-1:-1;;57148:14:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57122:13;;57148:14;;57155:7;;57148:14;;57155:7;57148:14;;;;;;;;;;;;;;;;;;;;;;;;79975:171;80030:13;80070:11;;80060:7;:21;80056:36;;;-1:-1:-1;80083:9:0;;;;;;;;;-1:-1:-1;80083:9:0;;;;80056:36;80116:4;;80110:28;;-1:-1:-1;;;80110:28:0;;-1:-1:-1;;;;;80116:4:0;;;;80110:19;;:28;;80130:7;;80110:28;;;:::i;74008:19::-;;;-1:-1:-1;;;;;74008:19:0;;:::o;80154:173::-;80210:13;80250:11;;80240:7;:21;80236:36;;;-1:-1:-1;80263:9:0;;;;;;;;;-1:-1:-1;80263:9:0;;;;80236:36;80296:4;;80290:29;;-1:-1:-1;;;80290:29:0;;-1:-1:-1;;;;;80296:4:0;;;;80290:20;;:29;;80311:7;;80290:29;;;:::i;74900:114::-;49048:12;:10;:12::i;:::-;-1:-1:-1;;;;;49037:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;49037:23:0;;49029:68;;;;-1:-1:-1;;;49029:68:0;;;;;;;:::i;:::-;74978:12:::1;:28:::0;;-1:-1:-1;;;;;;74978:28:0::1;-1:-1:-1::0;;;;;74978:28:0;;;::::1;::::0;;;::::1;::::0;;74900:114::o;79611:175::-;79668:13;79708:11;;79698:7;:21;79694:36;;;-1:-1:-1;79721:9:0;;;;;;;;;-1:-1:-1;79721:9:0;;;;79694:36;79754:4;;79748:30;;-1:-1:-1;;;79748:30:0;;-1:-1:-1;;;;;79754:4:0;;;;79748:21;;:30;;79770:7;;79748:30;;;:::i;59952:295::-;60067:12;:10;:12::i;:::-;-1:-1:-1;;;;;60055:24:0;:8;-1:-1:-1;;;;;60055:24:0;;;60047:62;;;;-1:-1:-1;;;60047:62:0;;;;;;;:::i;:::-;60167:8;60122:18;:32;60141:12;:10;:12::i;:::-;-1:-1:-1;;;;;60122:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;60122:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;60122:53:0;;;;;;;;;;;60206:12;:10;:12::i;:::-;-1:-1:-1;;;;;60191:48:0;;60230:8;60191:48;;;;;;:::i;:::-;;;;;;;;59952:295;;:::o;76886:395::-;71920:1;72526:7;;:19;;72518:63;;;;-1:-1:-1;;;72518:63:0;;;;;;;:::i;:::-;71920:1;72659:7;:18;77017:6:::1;::::0;-1:-1:-1;;;;;77017:6:0::1;77027:10;77017:20;77009:40;;;;-1:-1:-1::0;;;77009:40:0::1;;;;;;;:::i;:::-;77079:4;77068:7;:15;;77060:37;;;;-1:-1:-1::0;;;77060:37:0::1;;;;;;;:::i;:::-;77116:7;:14:::0;77108:44:::1;;;;-1:-1:-1::0;;;77108:44:0::1;;;;;;;:::i;:::-;77182:7;77190:14:::0;;-1:-1:-1;;77190:18:0;;;77182:27;::::1;;;;;;;;;;;;;77171:7;:38;;77163:72;;;;-1:-1:-1::0;;;77163:72:0::1;;;;;;;:::i;61244:365::-:0;61433:41;61452:12;:10;:12::i;:::-;61466:7;61433:18;:41::i;:::-;61411:140;;;;-1:-1:-1;;;61411:140:0;;;;;;;:::i;:::-;61562:39;61576:4;61582:2;61586:7;61595:5;61562:13;:39::i;:::-;61244:365;;;;:::o;80872:171::-;80927:13;80967:11;;80957:7;:21;80953:36;;;-1:-1:-1;80980:9:0;;;;;;;;;-1:-1:-1;80980:9:0;;;;80953:36;81013:4;;81007:28;;-1:-1:-1;;;81007:28:0;;-1:-1:-1;;;;;81013:4:0;;;;81007:19;;:28;;81027:7;;81007:28;;;:::i;77312:276::-;77413:13;77444:21;77468:15;77475:7;77468:6;:15::i;:::-;77444:39;-1:-1:-1;;;;;;77501:29:0;;;:79;;77538:42;;-1:-1:-1;;;77538:42:0;;-1:-1:-1;;;;;77538:33:0;;;;;:42;;77572:7;;77538:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;77538:42:0;;;;;;;;;;;;:::i;:::-;77501:79;;;-1:-1:-1;;77501:79:0;;;;;;;;;-1:-1:-1;77501:79:0;;;77312:276;-1:-1:-1;77312:276:0:o;80514:171::-;80569:13;80609:11;;80599:7;:21;80595:36;;;-1:-1:-1;80622:9:0;;;;;;;;;-1:-1:-1;80622:9:0;;;;80595:36;80655:4;;80649:28;;-1:-1:-1;;;80649:28:0;;-1:-1:-1;;;;;80655:4:0;;;;80649:19;;:28;;80669:7;;80649:28;;;:::i;78841:199::-;78899:15;;:::i;:::-;78927:9;78939:30;78952:7;78939:30;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78961:7;78939:12;:30::i;:::-;78927:42;;78980:20;;:::i;:::-;-1:-1:-1;79003:7:0;;;;:4;:7;;;;;;;;;78980:30;;;;;;;;;-1:-1:-1;;;;;78980:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78841:199;-1:-1:-1;;78841:199:0:o;73891:27::-;;;-1:-1:-1;;;;;73891:27:0;;:::o;60318:156::-;-1:-1:-1;;;;;60431:25:0;;;60407:4;60431:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;60318:156::o;79794:173::-;79850:13;79890:11;;79880:7;:21;79876:36;;;-1:-1:-1;79903:9:0;;;;;;;;;-1:-1:-1;79903:9:0;;;;79876:36;79936:4;;79930:29;;-1:-1:-1;;;79930:29:0;;-1:-1:-1;;;;;79936:4:0;;;;79930:20;;:29;;79951:7;;79930:29;;;:::i;49771:244::-;49048:12;:10;:12::i;:::-;-1:-1:-1;;;;;49037:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;49037:23:0;;49029:68;;;;-1:-1:-1;;;49029:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;49860:22:0;::::1;49852:73;;;;-1:-1:-1::0;;;49852:73:0::1;;;;;;;:::i;:::-;49962:6;::::0;49941:38:::1;::::0;-1:-1:-1;;;;;49941:38:0;;::::1;::::0;49962:6:::1;::::0;49941:38:::1;::::0;49962:6:::1;::::0;49941:38:::1;49990:6;:17:::0;;-1:-1:-1;;;;;;49990:17:0::1;-1:-1:-1::0;;;;;49990:17:0;;;::::1;::::0;;;::::1;::::0;;49771:244::o;74782:110::-;49048:12;:10;:12::i;:::-;-1:-1:-1;;;;;49037:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;49037:23:0;;49029:68;;;;-1:-1:-1;;;49029:68:0;;;;;;;:::i;:::-;74858:6:::1;:26:::0;;-1:-1:-1;;;;;;74858:26:0::1;-1:-1:-1::0;;;;;74858:26:0;;;::::1;::::0;;;::::1;::::0;;74782:110::o;64143:::-;64219:26;64229:2;64233:7;64219:26;;;;;;;;;;;;:9;:26::i;63155:119::-;63212:4;63236:30;:12;63258:7;63236:21;:30::i;6252:106::-;6340:10;6252:106;:::o;69252:158::-;69318:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;69318:29:0;-1:-1:-1;;;;;69318:29:0;;;;;;;;:24;;69372:16;69318:24;69372:7;:16::i;:::-;-1:-1:-1;;;;;69363:39:0;;;;;;;;;;;69252:158;;:::o;15706:123::-;15775:7;15802:19;15810:3;15802:7;:19::i;63441:359::-;63526:4;63551:16;63559:7;63551;:16::i;:::-;63543:73;;;;-1:-1:-1;;;63543:73:0;;;;;;;:::i;:::-;63627:13;63643:16;63651:7;63643;:16::i;:::-;63627:32;;63689:5;-1:-1:-1;;;;;63678:16:0;:7;-1:-1:-1;;;;;63678:16:0;;:64;;;;63735:7;-1:-1:-1;;;;;63711:31:0;:20;63723:7;63711:11;:20::i;:::-;-1:-1:-1;;;;;63711:31:0;;63678:64;:113;;;;63759:32;63776:5;63783:7;63759:16;:32::i;:::-;63670:122;63441:359;-1:-1:-1;;;;63441:359:0:o;66627:608::-;66779:4;-1:-1:-1;;;;;66759:24:0;:16;66767:7;66759;:16::i;:::-;-1:-1:-1;;;;;66759:24:0;;66751:78;;;;-1:-1:-1;;;66751:78:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;66848:16:0;;66840:65;;;;-1:-1:-1;;;66840:65:0;;;;;;;:::i;:::-;66918:39;66939:4;66945:2;66949:7;66918:20;:39::i;:::-;67022:29;67039:1;67043:7;67022:8;:29::i;:::-;-1:-1:-1;;;;;67064:19:0;;;;;;:13;:19;;;;;:35;;67091:7;67064:26;:35::i;:::-;-1:-1:-1;;;;;;67110:17:0;;;;;;:13;:17;;;;;:30;;67132:7;67110:21;:30::i;:::-;-1:-1:-1;67153:29:0;:12;67170:7;67179:2;67153:16;:29::i;:::-;;67219:7;67215:2;-1:-1:-1;;;;;67200:27:0;67209:4;-1:-1:-1;;;;;67200:27:0;;;;;;;;;;;66627:608;;;:::o;27264:137::-;27335:7;27370:22;27374:3;27386:5;27370:3;:22::i;16168:236::-;16248:7;;;;16308:22;16312:3;16324:5;16308:3;:22::i;:::-;16277:53;;;;-1:-1:-1;16168:236:0;-1:-1:-1;;;;;16168:236:0:o;17454:213::-;17561:7;17612:44;17617:3;17637;17643:12;17612:4;:44::i;62490:352::-;62647:28;62657:4;62663:2;62667:7;62647:9;:28::i;:::-;62708:48;62731:4;62737:2;62741:7;62750:5;62708:22;:48::i;:::-;62686:148;;;;-1:-1:-1;;;62686:148:0;;;;;;;:::i;77744:1089::-;77857:7;77975:5;:12;77991:1;77975:17;:54;;;;78006:5;78027:1;78012:5;:12;:16;78006:23;;;;;;;;;;;;;;77996:7;:33;77975:54;77971:111;;;-1:-1:-1;;;78046:24:0;;77971:111;78135:12;;78094:11;;78160:424;78173:4;78167:3;:10;78160:424;;;78194:11;78208:23;78221:3;78226:4;78208:12;:23::i;:::-;78194:37;;78465:7;78452:5;78458:3;78452:10;;;;;;;;;;;;;;:20;78448:125;;;78500:3;78493:10;;78448:125;;;78550:3;78556:1;78550:7;78544:13;;78448:125;78160:424;;;;78710:1;78704:3;:7;:36;;;;;78733:7;78715:5;78727:1;78721:3;:7;78715:14;;;;;;;;;;;;;;:25;78704:36;78700:126;;;-1:-1:-1;;;78764:7:0;;-1:-1:-1;78757:14:0;;78700:126;-1:-1:-1;78811:3:0;-1:-1:-1;78804:10:0;;64480:321;64610:18;64616:2;64620:7;64610:5;:18::i;:::-;64661:54;64692:1;64696:2;64700:7;64709:5;64661:22;:54::i;:::-;64639:154;;;;-1:-1:-1;;;64639:154:0;;;;;;;:::i;15467:151::-;15551:4;15575:35;15585:3;15605;15575:9;:35::i;12285:110::-;12368:19;;12285:110::o;26351:137::-;26421:4;26445:35;26453:3;26473:5;26445:7;:35::i;26044:131::-;26111:4;26135:32;26140:3;26160:5;26135:4;:32::i;14890:185::-;14979:4;15003:64;15008:3;15028;-1:-1:-1;;;;;15042:23:0;;15003:4;:64::i;22302:204::-;22397:18;;22369:7;;22397:26;-1:-1:-1;22389:73:0;;;;-1:-1:-1;;;22389:73:0;;;;;;;:::i;:::-;22480:3;:11;;22492:5;22480:18;;;;;;;;;;;;;;;;22473:25;;22302:204;;;;:::o;12750:279::-;12854:19;;12817:7;;;;12854:27;-1:-1:-1;12846:74:0;;;;-1:-1:-1;;;12846:74:0;;;;;;;:::i;:::-;12933:22;12958:3;:12;;12971:5;12958:19;;;;;;;;;;;;;;;;;;12933:44;;12996:5;:10;;;13008:5;:12;;;12988:33;;;;;12750:279;;;;;:::o;14247:319::-;14341:7;14380:17;;;:12;;;:17;;;;;;14431:12;14416:13;14408:36;;;;-1:-1:-1;;;14408:36:0;;;;;;;;:::i;:::-;;14498:3;:12;;14522:1;14511:8;:12;14498:26;;;;;;;;;;;;;;;;;;:33;;;14491:40;;;14247:319;;;;;:::o;68501:743::-;68656:4;68678:15;:2;-1:-1:-1;;;;;68678:13:0;;:15::i;:::-;68673:60;;-1:-1:-1;68717:4:0;68710:11;;68673:60;68743:23;68782:349;-1:-1:-1;;;68929:12:0;:10;:12::i;:::-;68964:4;68991:7;69021:5;68816:229;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;-1:-1:-1;;;;;68816:229:0;;;;;;;-1:-1:-1;;;;;68816:229:0;;;;;;;;;;;68782:349;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;68782:15:0;;;:349;:15;:349::i;:::-;68743:388;;69142:13;69169:10;69158:32;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;69209:26:0;-1:-1:-1;;;69209:26:0;;-1:-1:-1;;;68501:743:0;;;;;;:::o;73540:156::-;73687:1;73678:5;;;73677:11;73668:5;;73667:21;;73540:156::o;65137:404::-;-1:-1:-1;;;;;65217:16:0;;65209:61;;;;-1:-1:-1;;;65209:61:0;;;;;;;:::i;:::-;65290:16;65298:7;65290;:16::i;:::-;65289:17;65281:58;;;;-1:-1:-1;;;65281:58:0;;;;;;;:::i;:::-;65352:45;65381:1;65385:2;65389:7;65352:20;:45::i;:::-;-1:-1:-1;;;;;65410:17:0;;;;;;:13;:17;;;;;:30;;65432:7;65410:21;:30::i;:::-;-1:-1:-1;65453:29:0;:12;65470:7;65479:2;65453:16;:29::i;:::-;-1:-1:-1;65500:33:0;;65525:7;;-1:-1:-1;;;;;65500:33:0;;;65517:1;;65500:33;;65517:1;;65500:33;65137:404;;:::o;12065:125::-;12136:4;12160:17;;;:12;;;;;:17;;;;;;:22;;;12065:125::o;20004:1544::-;20070:4;20209:19;;;:12;;;:19;;;;;;20245:15;;20241:1300;;20680:18;;-1:-1:-1;;20631:14:0;;;;20680:22;;;;20607:21;;20680:3;;:22;;20967;;;;;;;;;;;;;;20947:42;;21113:9;21084:3;:11;;21096:13;21084:26;;;;;;;;;;;;;;;;;;;:38;;;;21190:23;;;21232:1;21190:12;;;:23;;;;;;21216:17;;;21190:43;;21342:17;;21190:3;;21342:17;;;;;;;;;;;;;;;;;;;;;;21437:3;:12;;:19;21450:5;21437:19;;;;;;;;;;;21430:26;;;21480:4;21473:11;;;;;;;;20241:1300;21524:5;21517:12;;;;;19414:414;19477:4;19499:21;19509:3;19514:5;19499:9;:21::i;:::-;19494:327;;-1:-1:-1;19537:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;19720:18;;19698:19;;;:12;;;:19;;;;;;:40;;;;19753:11;;19494:327;-1:-1:-1;19804:5:0;19797:12;;9565:692;9641:4;9776:17;;;:12;;;:17;;;;;;9810:13;9806:444;;-1:-1:-1;;9895:38:0;;;;;;;;;;;;;;;;;;9877:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;10092:19;;10072:17;;;:12;;;:17;;;;;;;:39;10126:11;;9806:444;10206:5;10170:3;:12;;10194:1;10183:8;:12;10170:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;10233:5;10226:12;;;;;28208:422;28575:20;28614:8;;;28208:422::o;31130:195::-;31233:12;31265:52;31287:6;31295:4;31301:1;31304:12;31233;32434:18;32445:6;32434:10;:18::i;:::-;32426:60;;;;-1:-1:-1;;;32426:60:0;;;;;;;:::i;:::-;32560:12;32574:23;32601:6;-1:-1:-1;;;;;32601:11:0;32621:5;32629:4;32601:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32559:75;;;;32652:52;32670:7;32679:10;32691:12;32652:17;:52::i;:::-;32645:59;32182:530;-1:-1:-1;;;;;;;32182:530:0:o;34722:742::-;34837:12;34866:7;34862:595;;;-1:-1:-1;34897:10:0;34890:17;;34862:595;35011:17;;:21;35007:439;;35274:10;35268:17;35335:15;35322:10;35318:2;35314:19;35307:44;35222:148;35417:12;35410:20;;-1:-1:-1;;;35410:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;5:130::-;72:20;;-1:-1;;;;;37373:54;;38236:35;;38226:2;;38285:1;;38275:12;1723:241;;1827:2;1815:9;1806:7;1802:23;1798:32;1795:2;;;-1:-1;;1833:12;1795:2;1895:53;1940:7;1916:22;1895:53;:::i;1971:366::-;;;2092:2;2080:9;2071:7;2067:23;2063:32;2060:2;;;-1:-1;;2098:12;2060:2;2160:53;2205:7;2181:22;2160:53;:::i;:::-;2150:63;;2268:53;2313:7;2250:2;2293:9;2289:22;2268:53;:::i;:::-;2258:63;;2054:283;;;;;:::o;2344:491::-;;;;2482:2;2470:9;2461:7;2457:23;2453:32;2450:2;;;-1:-1;;2488:12;2450:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2540:63;-1:-1;2640:2;2679:22;;72:20;97:33;72:20;97:33;:::i;:::-;2444:391;;2648:63;;-1:-1;;;2748:2;2787:22;;;;1653:20;;2444:391::o;2842:721::-;;;;;3006:3;2994:9;2985:7;2981:23;2977:33;2974:2;;;-1:-1;;3013:12;2974:2;3075:53;3120:7;3096:22;3075:53;:::i;:::-;3065:63;;3183:53;3228:7;3165:2;3208:9;3204:22;3183:53;:::i;:::-;3173:63;;3273:2;3316:9;3312:22;1653:20;3281:63;;3409:2;3398:9;3394:18;3381:32;3433:18;3425:6;3422:30;3419:2;;;-1:-1;;3455:12;3419:2;3515:22;;779:4;767:17;;763:27;-1:-1;753:2;;-1:-1;;794:12;753:2;841:6;828:20;863:64;878:48;919:6;878:48;:::i;:::-;863:64;:::i;:::-;947:6;940:5;933:21;1051:3;3165:2;1042:6;975;1033:16;;1030:25;1027:2;;;-1:-1;;1058:12;1027:2;37723:6;3165:2;975:6;971:17;3165:2;1009:5;1005:16;37700:30;37761:16;;;3165:2;37761:16;37754:27;;;;-1:-1;2968:595;;;;-1:-1;2968:595;-1:-1;2968:595::o;3570:360::-;;;3688:2;3676:9;3667:7;3663:23;3659:32;3656:2;;;-1:-1;;3694:12;3656:2;3756:53;3801:7;3777:22;3756:53;:::i;:::-;3746:63;;3846:2;3886:9;3882:22;206:20;38382:5;37055:13;37048:21;38360:5;38357:32;38347:2;;-1:-1;;38393:12;38347:2;3854:60;;;;3650:280;;;;;:::o;3937:366::-;;;4058:2;4046:9;4037:7;4033:23;4029:32;4026:2;;;-1:-1;;4064:12;4026:2;4126:53;4171:7;4147:22;4126:53;:::i;:::-;4116:63;4216:2;4255:22;;;;1653:20;;-1:-1;;;4020:283::o;4310:241::-;;4414:2;4402:9;4393:7;4389:23;4385:32;4382:2;;;-1:-1;;4420:12;4382:2;-1:-1;340:20;;4376:175;-1:-1;4376:175::o;4558:239::-;;4661:2;4649:9;4640:7;4636:23;4632:32;4629:2;;;-1:-1;;4667:12;4629:2;489:6;476:20;501:32;527:5;501:32;:::i;4804:261::-;;4918:2;4906:9;4897:7;4893:23;4889:32;4886:2;;;-1:-1;;4924:12;4886:2;628:6;622:13;640:32;666:5;640:32;:::i;5072:362::-;;5197:2;5185:9;5176:7;5172:23;5168:32;5165:2;;;-1:-1;;5203:12;5165:2;5254:17;5248:24;5292:18;5284:6;5281:30;5278:2;;;-1:-1;;5314:12;5278:2;5386:22;;1240:4;1228:17;;1224:27;-1:-1;1214:2;;-1:-1;;1255:12;1214:2;1295:6;1289:13;1317:65;1332:49;1374:6;1332:49;:::i;1317:65::-;1402:6;1395:5;1388:21;1506:3;5197:2;1497:6;1430;1488:16;;1485:25;1482:2;;;-1:-1;;1513:12;1482:2;1533:39;1565:6;5197:2;1464:5;1460:16;5197:2;1430:6;1426:17;1533:39;:::i;:::-;5334:84;5159:275;-1:-1;;;;;5159:275::o;6275:343::-;;6417:5;35965:12;36250:6;36245:3;36238:19;6510:52;6555:6;36287:4;36282:3;36278:14;36287:4;6536:5;6532:16;6510:52;:::i;:::-;38156:7;38140:14;-1:-1;;38136:28;6574:39;;;;36287:4;6574:39;;6365:253;-1:-1;;6365:253::o;18904:271::-;;6785:5;35965:12;6896:52;6941:6;6936:3;6929:4;6922:5;6918:16;6896:52;:::i;:::-;6960:16;;;;;19038:137;-1:-1;;19038:137::o;19464:222::-;-1:-1;;;;;37373:54;;;;5776:45;;19591:2;19576:18;;19562:124::o;19693:672::-;-1:-1;;;;;37373:54;;;5776:45;;37373:54;;20119:2;20104:18;;5776:45;20202:2;20187:18;;18735:37;;;19938:3;20239:2;20224:18;;20217:48;;;19693:672;;20279:76;;19923:19;;20341:6;20279:76;:::i;:::-;20271:84;19909:456;-1:-1;;;;;;19909:456::o;20372:544::-;-1:-1;;;;;37373:54;;;;5776:45;;20742:2;20727:18;;18735:37;;;;20825:2;20810:18;;18735:37;37055:13;37048:21;20902:2;20887:18;;6118:34;20577:3;20562:19;;20548:368::o;20923:210::-;37055:13;;37048:21;6118:34;;21044:2;21029:18;;21015:118::o;21140:310::-;;21287:2;21308:17;21301:47;21362:78;21287:2;21276:9;21272:18;21426:6;21362:78;:::i;21457:548::-;;21668:2;21689:17;21682:47;21743:78;21668:2;21657:9;21653:18;21807:6;21743:78;:::i;:::-;21908:2;21893:18;;7067:58;;;;-1:-1;21991:2;21976:18;18735:37;21735:86;21639:366;-1:-1;21639:366::o;22551:416::-;22751:2;22765:47;;;8083:2;22736:18;;;36238:19;8119:34;36278:14;;;8099:55;-1:-1;;;8174:12;;;8167:26;8212:12;;;22722:245::o;22974:416::-;23174:2;23188:47;;;8463:2;23159:18;;;36238:19;8499:34;36278:14;;;8479:55;-1:-1;;;8554:12;;;8547:42;8608:12;;;23145:245::o;23397:416::-;23597:2;23611:47;;;8859:2;23582:18;;;36238:19;8895:34;36278:14;;;8875:55;-1:-1;;;8950:12;;;8943:30;8992:12;;;23568:245::o;23820:416::-;24020:2;24034:47;;;9243:2;24005:18;;;36238:19;9279:30;36278:14;;;9259:51;9329:12;;;23991:245::o;24243:416::-;24443:2;24457:47;;;9580:2;24428:18;;;36238:19;-1:-1;;;36278:14;;;9596:40;9655:12;;;24414:245::o;24666:416::-;24866:2;24880:47;;;9906:2;24851:18;;;36238:19;9942:34;36278:14;;;9922:55;-1:-1;;;9997:12;;;9990:28;10037:12;;;24837:245::o;25089:416::-;25289:2;25303:47;;;10288:2;25274:18;;;36238:19;10324:27;36278:14;;;10304:48;10371:12;;;25260:245::o;25935:416::-;26135:2;26149:47;;;11006:2;26120:18;;;36238:19;11042:34;36278:14;;;11022:55;-1:-1;;;11097:12;;;11090:36;11145:12;;;26106:245::o;26358:416::-;26558:2;26572:47;;;11396:2;26543:18;;;36238:19;-1:-1;;;36278:14;;;11412:36;11467:12;;;26529:245::o;26781:416::-;26981:2;26995:47;;;11718:2;26966:18;;;36238:19;-1:-1;;;36278:14;;;11734:40;11793:12;;;26952:245::o;27204:416::-;27404:2;27418:47;;;12044:2;27389:18;;;36238:19;-1:-1;;;36278:14;;;12060:39;12118:12;;;27375:245::o;27627:416::-;27827:2;27841:47;;;12369:2;27812:18;;;36238:19;-1:-1;;;36278:14;;;12385:37;12441:12;;;27798:245::o;28050:416::-;28250:2;28264:47;;;12692:2;28235:18;;;36238:19;12728:34;36278:14;;;12708:55;12797:26;12783:12;;;12776:48;12843:12;;;28221:245::o;28473:416::-;28673:2;28687:47;;;13094:2;28658:18;;;36238:19;13130:34;36278:14;;;13110:55;-1:-1;;;13185:12;;;13178:34;13231:12;;;28644:245::o;28896:416::-;29096:2;29110:47;;;13482:2;29081:18;;;36238:19;13518:34;36278:14;;;13498:55;-1:-1;;;13573:12;;;13566:26;13611:12;;;29067:245::o;29319:416::-;29519:2;29533:47;;;29504:18;;;36238:19;13898:34;36278:14;;;13878:55;13952:12;;;29490:245::o;29742:416::-;29942:2;29956:47;;;14203:2;29927:18;;;36238:19;14239:34;36278:14;;;14219:55;-1:-1;;;14294:12;;;14287:36;14342:12;;;29913:245::o;30165:416::-;30365:2;30379:47;;;30350:18;;;36238:19;14629:34;36278:14;;;14609:55;14683:12;;;30336:245::o;30588:416::-;30788:2;30802:47;;;14934:1;30773:18;;;36238:19;-1:-1;;;36278:14;;;14949:32;15000:12;;;30759:245::o;31011:416::-;31211:2;31225:47;;;15251:2;31196:18;;;36238:19;15287:34;36278:14;;;15267:55;-1:-1;;;15342:12;;;15335:33;15387:12;;;31182:245::o;31434:416::-;31634:2;31648:47;;;15638:2;31619:18;;;36238:19;15674:34;36278:14;;;15654:55;-1:-1;;;15729:12;;;15722:25;15766:12;;;31605:245::o;31857:416::-;32057:2;32071:47;;;16017:2;32042:18;;;36238:19;-1:-1;;;36278:14;;;16033:37;16089:12;;;32028:245::o;32280:416::-;32480:2;32494:47;;;16340:2;32465:18;;;36238:19;16376:34;36278:14;;;16356:55;-1:-1;;;16431:12;;;16424:41;16484:12;;;32451:245::o;32703:416::-;32903:2;32917:47;;;16735:2;32888:18;;;36238:19;16771:31;36278:14;;;16751:52;16822:12;;;32874:245::o;33126:416::-;33326:2;33340:47;;;17073:2;33311:18;;;36238:19;-1:-1;;;36278:14;;;17089:44;17152:12;;;33297:245::o;33549:416::-;33749:2;33763:47;;;17403:2;33734:18;;;36238:19;17439:33;36278:14;;;17419:54;17492:12;;;33720:245::o;33972:416::-;34172:2;34186:47;;;17743:1;34157:18;;;36238:19;-1:-1;;;36278:14;;;17758:30;17807:12;;;34143:245::o;34395:327::-;18096:23;;-1:-1;;;;;37373:54;5776:45;;18268:4;18257:16;;;18251:23;18328:14;;;18735:37;18421:4;18410:16;;;18404:23;18481:14;;;18735:37;18577:4;18566:16;;;18560:23;37055:13;37048:21;18631:14;;;6118:34;;;;34574:3;34559:19;;34545:177::o;34729:222::-;18735:37;;;34856:2;34841:18;;34827:124::o;34958:256::-;35020:2;35014:9;35046:17;;;35121:18;35106:34;;35142:22;;;35103:62;35100:2;;;35178:1;;35168:12;35100:2;35020;35187:22;34998:216;;-1:-1;34998:216::o;35221:321::-;;35364:18;35356:6;35353:30;35350:2;;;-1:-1;;35386:12;35350:2;-1:-1;38156:7;35440:17;-1:-1;;35436:33;35527:4;35517:15;;35287:255::o;37796:268::-;37861:1;37868:101;37882:6;37879:1;37876:13;37868:101;;;37949:11;;;37943:18;37930:11;;;37923:39;37904:2;37897:10;37868:101;;;37984:6;37981:1;37978:13;37975:2;;;-1:-1;;37861:1;38031:16;;38024:27;37845:219::o;38177:117::-;-1:-1;;;;;37373:54;;38236:35;;38226:2;;38285:1;;38275:12;38226:2;38220:74;:::o;38543:115::-;-1:-1;;;;;;37221:78;;38601:34;;38591:2;;38649:1;;38639:12
Metadata Hash
ipfs://e6cbf2108be7211dade99c67284f4d196115fdf5a207927102c391c750f3bd1e