ERC-721
Overview
Max Total Supply
155 HAG
Holders
99
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
1 HAGLoading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
HypeAliensGenesis
Compiler Version
v0.8.17+commit.8df45f5f
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2023-03-31 */ // File: contracts/lib/Constants.sol pragma solidity ^0.8.13; address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E; address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6; // File: contracts/IOperatorFilterRegistry.sol pragma solidity ^0.8.13; interface IOperatorFilterRegistry { /** * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns * true if supplied registrant address is not registered. */ function isOperatorAllowed(address registrant, address operator) external view returns (bool); /** * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner. */ function register(address registrant) external; /** * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes. */ function registerAndSubscribe(address registrant, address subscription) external; /** * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another * address without subscribing. */ function registerAndCopyEntries(address registrant, address registrantToCopy) external; /** * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner. * Note that this does not remove any filtered addresses or codeHashes. * Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes. */ function unregister(address addr) external; /** * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered. */ function updateOperator(address registrant, address operator, bool filtered) external; /** * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates. */ function updateOperators(address registrant, address[] calldata operators, bool filtered) external; /** * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered. */ function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external; /** * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates. */ function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external; /** * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous * subscription if present. * Note that accounts with subscriptions may go on to subscribe to other accounts - in this case, * subscriptions will not be forwarded. Instead the former subscription's existing entries will still be * used. */ function subscribe(address registrant, address registrantToSubscribe) external; /** * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes. */ function unsubscribe(address registrant, bool copyExistingEntries) external; /** * @notice Get the subscription address of a given registrant, if any. */ function subscriptionOf(address addr) external returns (address registrant); /** * @notice Get the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscribers(address registrant) external returns (address[] memory); /** * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscriberAt(address registrant, uint256 index) external returns (address); /** * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr. */ function copyEntriesOf(address registrant, address registrantToCopy) external; /** * @notice Returns true if operator is filtered by a given address or its subscription. */ function isOperatorFiltered(address registrant, address operator) external returns (bool); /** * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription. */ function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool); /** * @notice Returns true if a codeHash is filtered by a given address or its subscription. */ function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool); /** * @notice Returns a list of filtered operators for a given address or its subscription. */ function filteredOperators(address addr) external returns (address[] memory); /** * @notice Returns the set of filtered codeHashes for a given address or its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashes(address addr) external returns (bytes32[] memory); /** * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredOperatorAt(address registrant, uint256 index) external returns (address); /** * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32); /** * @notice Returns true if an address has registered */ function isRegistered(address addr) external returns (bool); /** * @dev Convenience method to compute the code hash of an arbitrary contract */ function codeHashOf(address addr) external returns (bytes32); } // File: contracts/OperatorFilterer.sol pragma solidity ^0.8.13; /** * @title OperatorFilterer * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another * registrant's entries in the OperatorFilterRegistry. * @dev This smart contract is meant to be inherited by token contracts so they can use the following: * - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods. * - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods. * Please note that if your token contract does not provide an owner with EIP-173, it must provide * administration methods on the contract itself to interact with the registry otherwise the subscription * will be locked to the options set during construction. */ abstract contract OperatorFilterer { /// @dev Emitted when an operator is not allowed. error OperatorNotAllowed(address operator); bool public operatorFilteringEnabled = true; IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY = IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS); /// @dev The constructor that is called when the contract is being deployed. constructor(address subscriptionOrRegistrantToCopy, bool subscribe) { // If an inheriting token contract is deployed to a network without the registry deployed, the modifier // will not revert, but the contract will need to be registered with the registry once it is deployed in // order for the modifier to filter addresses. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) { if (subscribe) { OPERATOR_FILTER_REGISTRY.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy); } else { if (subscriptionOrRegistrantToCopy != address(0)) { OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy); } else { OPERATOR_FILTER_REGISTRY.register(address(this)); } } } } modifier onlyAllowedOperator(address from) virtual { // Check registry code length to facilitate testing in environments without a deployed registry. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0 && operatorFilteringEnabled) { // Allow spending tokens from addresses with balance // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred // from an EOA. if (from == msg.sender) { _; return; } if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), msg.sender)) { revert OperatorNotAllowed(msg.sender); } } _; } modifier onlyAllowedOperatorApproval(address operator) virtual { // Check registry code length to facilitate testing in environments without a deployed registry. if (address(OPERATOR_FILTER_REGISTRY).code.length > 0 && operatorFilteringEnabled) { if (!OPERATOR_FILTER_REGISTRY.isOperatorAllowed(address(this), operator)) { revert OperatorNotAllowed(operator); } } _; } } // File: contracts/DefaultOperatorFilterer.sol pragma solidity ^0.8.13; /** * @title DefaultOperatorFilterer * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription. */ abstract contract DefaultOperatorFilterer is OperatorFilterer { address constant DEFAULT_SUBSCRIPTION = address(0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6); constructor() OperatorFilterer(DEFAULT_SUBSCRIPTION, true) {} } // File: @chainlink/contracts/src/v0.8/VRFConsumerBaseV2.sol pragma solidity ^0.8.4; /** **************************************************************************** * @notice Interface for contracts using VRF randomness * ***************************************************************************** * @dev PURPOSE * * @dev Reggie the Random Oracle (not his real job) wants to provide randomness * @dev to Vera the verifier in such a way that Vera can be sure he's not * @dev making his output up to suit himself. Reggie provides Vera a public key * @dev to which he knows the secret key. Each time Vera provides a seed to * @dev Reggie, he gives back a value which is computed completely * @dev deterministically from the seed and the secret key. * * @dev Reggie provides a proof by which Vera can verify that the output was * @dev correctly computed once Reggie tells it to her, but without that proof, * @dev the output is indistinguishable to her from a uniform random sample * @dev from the output space. * * @dev The purpose of this contract is to make it easy for unrelated contracts * @dev to talk to Vera the verifier about the work Reggie is doing, to provide * @dev simple access to a verifiable source of randomness. It ensures 2 things: * @dev 1. The fulfillment came from the VRFCoordinator * @dev 2. The consumer contract implements fulfillRandomWords. * ***************************************************************************** * @dev USAGE * * @dev Calling contracts must inherit from VRFConsumerBase, and can * @dev initialize VRFConsumerBase's attributes in their constructor as * @dev shown: * * @dev contract VRFConsumer { * @dev constructor(<other arguments>, address _vrfCoordinator, address _link) * @dev VRFConsumerBase(_vrfCoordinator) public { * @dev <initialization with other arguments goes here> * @dev } * @dev } * * @dev The oracle will have given you an ID for the VRF keypair they have * @dev committed to (let's call it keyHash). Create subscription, fund it * @dev and your consumer contract as a consumer of it (see VRFCoordinatorInterface * @dev subscription management functions). * @dev Call requestRandomWords(keyHash, subId, minimumRequestConfirmations, * @dev callbackGasLimit, numWords), * @dev see (VRFCoordinatorInterface for a description of the arguments). * * @dev Once the VRFCoordinator has received and validated the oracle's response * @dev to your request, it will call your contract's fulfillRandomWords method. * * @dev The randomness argument to fulfillRandomWords is a set of random words * @dev generated from your requestId and the blockHash of the request. * * @dev If your contract could have concurrent requests open, you can use the * @dev requestId returned from requestRandomWords to track which response is associated * @dev with which randomness request. * @dev See "SECURITY CONSIDERATIONS" for principles to keep in mind, * @dev if your contract could have multiple requests in flight simultaneously. * * @dev Colliding `requestId`s are cryptographically impossible as long as seeds * @dev differ. * * ***************************************************************************** * @dev SECURITY CONSIDERATIONS * * @dev A method with the ability to call your fulfillRandomness method directly * @dev could spoof a VRF response with any random value, so it's critical that * @dev it cannot be directly called by anything other than this base contract * @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method). * * @dev For your users to trust that your contract's random behavior is free * @dev from malicious interference, it's best if you can write it so that all * @dev behaviors implied by a VRF response are executed *during* your * @dev fulfillRandomness method. If your contract must store the response (or * @dev anything derived from it) and use it later, you must ensure that any * @dev user-significant behavior which depends on that stored value cannot be * @dev manipulated by a subsequent VRF request. * * @dev Similarly, both miners and the VRF oracle itself have some influence * @dev over the order in which VRF responses appear on the blockchain, so if * @dev your contract could have multiple VRF requests in flight simultaneously, * @dev you must ensure that the order in which the VRF responses arrive cannot * @dev be used to manipulate your contract's user-significant behavior. * * @dev Since the block hash of the block which contains the requestRandomness * @dev call is mixed into the input to the VRF *last*, a sufficiently powerful * @dev miner could, in principle, fork the blockchain to evict the block * @dev containing the request, forcing the request to be included in a * @dev different block with a different hash, and therefore a different input * @dev to the VRF. However, such an attack would incur a substantial economic * @dev cost. This cost scales with the number of blocks the VRF oracle waits * @dev until it calls responds to a request. It is for this reason that * @dev that you can signal to an oracle you'd like them to wait longer before * @dev responding to the request (however this is not enforced in the contract * @dev and so remains effective only in the case of unmodified oracle software). */ abstract contract VRFConsumerBaseV2 { error OnlyCoordinatorCanFulfill(address have, address want); address private immutable vrfCoordinator; /** * @param _vrfCoordinator address of VRFCoordinator contract */ constructor(address _vrfCoordinator) { vrfCoordinator = _vrfCoordinator; } /** * @notice fulfillRandomness handles the VRF response. Your contract must * @notice implement it. See "SECURITY CONSIDERATIONS" above for important * @notice principles to keep in mind when implementing your fulfillRandomness * @notice method. * * @dev VRFConsumerBaseV2 expects its subcontracts to have a method with this * @dev signature, and will call it once it has verified the proof * @dev associated with the randomness. (It is triggered via a call to * @dev rawFulfillRandomness, below.) * * @param requestId The Id initially returned by requestRandomness * @param randomWords the VRF output expanded to the requested number of words */ function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal virtual; // rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF // proof. rawFulfillRandomness then calls fulfillRandomness, after validating // the origin of the call function rawFulfillRandomWords(uint256 requestId, uint256[] memory randomWords) external { if (msg.sender != vrfCoordinator) { revert OnlyCoordinatorCanFulfill(msg.sender, vrfCoordinator); } fulfillRandomWords(requestId, randomWords); } } // File: @chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol pragma solidity ^0.8.0; interface VRFCoordinatorV2Interface { /** * @notice Get configuration relevant for making requests * @return minimumRequestConfirmations global min for request confirmations * @return maxGasLimit global max for request gas limit * @return s_provingKeyHashes list of registered key hashes */ function getRequestConfig() external view returns ( uint16, uint32, bytes32[] memory ); /** * @notice Request a set of random words. * @param keyHash - Corresponds to a particular oracle job which uses * that key for generating the VRF proof. Different keyHash's have different gas price * ceilings, so you can select a specific one to bound your maximum per request cost. * @param subId - The ID of the VRF subscription. Must be funded * with the minimum subscription balance required for the selected keyHash. * @param minimumRequestConfirmations - How many blocks you'd like the * oracle to wait before responding to the request. See SECURITY CONSIDERATIONS * for why you may want to request more. The acceptable range is * [minimumRequestBlockConfirmations, 200]. * @param callbackGasLimit - How much gas you'd like to receive in your * fulfillRandomWords callback. Note that gasleft() inside fulfillRandomWords * may be slightly less than this amount because of gas used calling the function * (argument decoding etc.), so you may need to request slightly more than you expect * to have inside fulfillRandomWords. The acceptable range is * [0, maxGasLimit] * @param numWords - The number of uint256 random values you'd like to receive * in your fulfillRandomWords callback. Note these numbers are expanded in a * secure way by the VRFCoordinator from a single random value supplied by the oracle. * @return requestId - A unique identifier of the request. Can be used to match * a request to a response in fulfillRandomWords. */ function requestRandomWords( bytes32 keyHash, uint64 subId, uint16 minimumRequestConfirmations, uint32 callbackGasLimit, uint32 numWords ) external returns (uint256 requestId); /** * @notice Create a VRF subscription. * @return subId - A unique subscription id. * @dev You can manage the consumer set dynamically with addConsumer/removeConsumer. * @dev Note to fund the subscription, use transferAndCall. For example * @dev LINKTOKEN.transferAndCall( * @dev address(COORDINATOR), * @dev amount, * @dev abi.encode(subId)); */ function createSubscription() external returns (uint64 subId); /** * @notice Get a VRF subscription. * @param subId - ID of the subscription * @return balance - LINK balance of the subscription in juels. * @return reqCount - number of requests for this subscription, determines fee tier. * @return owner - owner of the subscription. * @return consumers - list of consumer address which are able to use this subscription. */ function getSubscription(uint64 subId) external view returns ( uint96 balance, uint64 reqCount, address owner, address[] memory consumers ); /** * @notice Request subscription owner transfer. * @param subId - ID of the subscription * @param newOwner - proposed new owner of the subscription */ function requestSubscriptionOwnerTransfer(uint64 subId, address newOwner) external; /** * @notice Request subscription owner transfer. * @param subId - ID of the subscription * @dev will revert if original owner of subId has * not requested that msg.sender become the new owner. */ function acceptSubscriptionOwnerTransfer(uint64 subId) external; /** * @notice Add a consumer to a VRF subscription. * @param subId - ID of the subscription * @param consumer - New consumer which can use the subscription */ function addConsumer(uint64 subId, address consumer) external; /** * @notice Remove a consumer from a VRF subscription. * @param subId - ID of the subscription * @param consumer - Consumer to remove from the subscription */ function removeConsumer(uint64 subId, address consumer) external; /** * @notice Cancel a subscription * @param subId - ID of the subscription * @param to - Where to send the remaining LINK to */ function cancelSubscription(uint64 subId, address to) external; /* * @notice Check to see if there exists a request commitment consumers * for all consumers and keyhashes for a given sub. * @param subId - ID of the subscription * @return true if there exists at least one unfulfilled request for the subscription, false * otherwise. */ function pendingRequestExists(uint64 subId) external view returns (bool); } // File: @chainlink/contracts/src/v0.8/interfaces/LinkTokenInterface.sol pragma solidity ^0.8.0; interface LinkTokenInterface { function allowance(address owner, address spender) external view returns (uint256 remaining); function approve(address spender, uint256 value) external returns (bool success); function balanceOf(address owner) external view returns (uint256 balance); function decimals() external view returns (uint8 decimalPlaces); function decreaseApproval(address spender, uint256 addedValue) external returns (bool success); function increaseApproval(address spender, uint256 subtractedValue) external; function name() external view returns (string memory tokenName); function symbol() external view returns (string memory tokenSymbol); function totalSupply() external view returns (uint256 totalTokensIssued); function transfer(address to, uint256 value) external returns (bool success); function transferAndCall( address to, uint256 value, bytes calldata data ) external returns (bool success); function transferFrom( address from, address to, uint256 value ) external returns (bool success); } // File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/structs/EnumerableSet.sol) pragma solidity ^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. * * [WARNING] * ==== * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable. * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info. * * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet. * ==== */ 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; if (lastIndex != toDeleteIndex) { 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] = valueIndex; // Replace lastValue's index to valueIndex } // 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) { return set._values[index]; } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function _values(Set storage set) private view returns (bytes32[] memory) { return set._values; } // 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); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(Bytes32Set storage set) internal view returns (bytes32[] memory) { return _values(set._inner); } // 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)))); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(AddressSet storage set) internal view returns (address[] memory) { bytes32[] memory store = _values(set._inner); address[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } // 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)); } /** * @dev Return the entire set in an array * * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that * this function has an unbounded cost, and using it as part of a state-changing function may render the function * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block. */ function values(UintSet storage set) internal view returns (uint256[] memory) { bytes32[] memory store = _values(set._inner); uint256[] memory result; /// @solidity memory-safe-assembly assembly { result := store } return result; } } // File: @openzeppelin/contracts/utils/Counters.sol // OpenZeppelin Contracts v4.4.1 (utils/Counters.sol) pragma solidity ^0.8.0; /** * @title Counters * @author Matt Condon (@shrugs) * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number * of elements in a mapping, issuing ERC721 ids, or counting request ids. * * Include with `using Counters for Counters.Counter;` */ library Counters { struct Counter { // This variable should never be directly accessed by users of the library: interactions must be restricted to // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add // this feature: see https://github.com/ethereum/solidity/issues/4637 uint256 _value; // default: 0 } function current(Counter storage counter) internal view returns (uint256) { return counter._value; } function increment(Counter storage counter) internal { unchecked { counter._value += 1; } } function decrement(Counter storage counter) internal { uint256 value = counter._value; require(value > 0, "Counter: decrement overflow"); unchecked { counter._value = value - 1; } } function reset(Counter storage counter) internal { counter._value = 0; } } // File: @openzeppelin/contracts/utils/math/SafeMath.sol // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ 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) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { 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) { unchecked { // 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) { unchecked { 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) { unchecked { 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) { return a + b; } /** * @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) { 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) { return a * b; } /** * @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. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { 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) { 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) { unchecked { 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. * * 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) { unchecked { 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) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File: @openzeppelin/contracts/security/ReentrancyGuard.sol // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // 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; } } // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return 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"); (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"); (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"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/interfaces/IERC2981.sol // OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol) pragma solidity ^0.8.0; /** * @dev Interface for the NFT Royalty Standard. * * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal * support for royalty payments across all NFT marketplaces and ecosystem participants. * * _Available since v4.5._ */ interface IERC2981 is IERC165 { /** * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of * exchange. The royalty amount is denominated and should be paid in that same unit of exchange. */ function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount); } // File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. * * _Available since v3.1._ */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch( address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values ); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the amount of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom( address from, address to, uint256 id, uint256 amount, bytes calldata data ) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom( address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data ) external; } // File: @openzeppelin/contracts/interfaces/IERC1155.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC1155.sol) pragma solidity ^0.8.0; // File: contracts/ICoin.sol pragma solidity ^0.8.17; interface ICoin is IERC1155{ function burn(address account,uint256 id,uint256 value) external ; } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: 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 Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File: @openzeppelin/contracts/interfaces/IERC721.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC721.sol) pragma solidity ^0.8.0; // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/common/ERC2981.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information. * * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first. * * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the * fee is specified in basis points by default. * * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported. * * _Available since v4.5._ */ abstract contract ERC2981 is IERC2981, ERC165 { struct RoyaltyInfo { address receiver; uint96 royaltyFraction; } RoyaltyInfo private _defaultRoyaltyInfo; mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) { return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId); } /** * @inheritdoc IERC2981 */ function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) { RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId]; if (royalty.receiver == address(0)) { royalty = _defaultRoyaltyInfo; } uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator(); return (royalty.receiver, royaltyAmount); } /** * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an * override. */ function _feeDenominator() internal pure virtual returns (uint96) { return 10000; } /** * @dev Sets the royalty information that all ids in this contract will default to. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual { require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice"); require(receiver != address(0), "ERC2981: invalid receiver"); _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Removes default royalty information. */ function _deleteDefaultRoyalty() internal virtual { delete _defaultRoyaltyInfo; } /** * @dev Sets the royalty information for a specific token id, overriding the global default. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setTokenRoyalty( uint256 tokenId, address receiver, uint96 feeNumerator ) internal virtual { require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice"); require(receiver != address(0), "ERC2981: Invalid parameters"); _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Resets royalty information for the token id back to the global default. */ function _resetTokenRoyalty(uint256 tokenId) internal virtual { delete _tokenRoyaltyInfo[tokenId]; } } // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // 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); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/token/ERC721/ERC721.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _owners[tokenId]; require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner 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: caller is not token 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 mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _owners[tokenId] != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _balances[to] += 1; _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(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 = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); _balances[owner] -= 1; delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(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(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _balances[from] -= 1; _balances[to] += 1; _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * 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` and `to` are never both zero. * * 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 {} /** * @dev Hook that is called after any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} } // File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol) pragma solidity ^0.8.0; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } /** * @dev 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 override { super._beforeTokenTransfer(from, to, tokenId); if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = ERC721.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete _allTokensIndex[tokenId]; _allTokens.pop(); } } // File: @openzeppelin/contracts/access/IAccessControl.sol // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol) pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { /** * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` * * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite * {RoleAdminChanged} not being emitted signaling this. * * _Available since v3.1._ */ event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole); /** * @dev Emitted when `account` is granted `role`. * * `sender` is the account that originated the contract call, an admin role * bearer except when using {AccessControl-_setupRole}. */ event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Emitted when `account` is revoked `role`. * * `sender` is the account that originated the contract call: * - if using `revokeRole`, it is the admin role bearer * - if using `renounceRole`, it is the role bearer (i.e. `account`) */ event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender); /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) external view returns (bool); /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {AccessControl-_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) external view returns (bytes32); /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function grantRole(bytes32 role, address account) external; /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. */ function revokeRole(bytes32 role, address account) external; /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been granted `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. */ function renounceRole(bytes32 role, address account) external; } // File: @openzeppelin/contracts/access/AccessControl.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/AccessControl.sol) pragma solidity ^0.8.0; /** * @dev Contract module that allows children to implement role-based access * control mechanisms. This is a lightweight version that doesn't allow enumerating role * members except through off-chain means by accessing the contract event logs. Some * applications may benefit from on-chain enumerability, for those cases see * {AccessControlEnumerable}. * * Roles are referred to by their `bytes32` identifier. These should be exposed * in the external API and be unique. The best way to achieve this is by * using `public constant` hash digests: * * ``` * bytes32 public constant MY_ROLE = keccak256("MY_ROLE"); * ``` * * Roles can be used to represent a set of permissions. To restrict access to a * function call, use {hasRole}: * * ``` * function foo() public { * require(hasRole(MY_ROLE, msg.sender)); * ... * } * ``` * * Roles can be granted and revoked dynamically via the {grantRole} and * {revokeRole} functions. Each role has an associated admin role, and only * accounts that have a role's admin role can call {grantRole} and {revokeRole}. * * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means * that only accounts with this role will be able to grant or revoke other * roles. More complex role relationships can be created by using * {_setRoleAdmin}. * * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to * grant and revoke this role. Extra precautions should be taken to secure * accounts that have been granted it. */ abstract contract AccessControl is Context, IAccessControl, ERC165 { struct RoleData { mapping(address => bool) members; bytes32 adminRole; } mapping(bytes32 => RoleData) private _roles; bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00; /** * @dev Modifier that checks that an account has a specific role. Reverts * with a standardized message including the required role. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ * * _Available since v4.1._ */ modifier onlyRole(bytes32 role) { _checkRole(role); _; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId); } /** * @dev Returns `true` if `account` has been granted `role`. */ function hasRole(bytes32 role, address account) public view virtual override returns (bool) { return _roles[role].members[account]; } /** * @dev Revert with a standard message if `_msgSender()` is missing `role`. * Overriding this function changes the behavior of the {onlyRole} modifier. * * Format of the revert message is described in {_checkRole}. * * _Available since v4.6._ */ function _checkRole(bytes32 role) internal view virtual { _checkRole(role, _msgSender()); } /** * @dev Revert with a standard message if `account` is missing `role`. * * The format of the revert reason is given by the following regular expression: * * /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/ */ function _checkRole(bytes32 role, address account) internal view virtual { if (!hasRole(role, account)) { revert( string( abi.encodePacked( "AccessControl: account ", Strings.toHexString(uint160(account), 20), " is missing role ", Strings.toHexString(uint256(role), 32) ) ) ); } } /** * @dev Returns the admin role that controls `role`. See {grantRole} and * {revokeRole}. * * To change a role's admin, use {_setRoleAdmin}. */ function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) { return _roles[role].adminRole; } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleGranted} event. */ function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _grantRole(role, account); } /** * @dev Revokes `role` from `account`. * * If `account` had been granted `role`, emits a {RoleRevoked} event. * * Requirements: * * - the caller must have ``role``'s admin role. * * May emit a {RoleRevoked} event. */ function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) { _revokeRole(role, account); } /** * @dev Revokes `role` from the calling account. * * Roles are often managed via {grantRole} and {revokeRole}: this function's * purpose is to provide a mechanism for accounts to lose their privileges * if they are compromised (such as when a trusted device is misplaced). * * If the calling account had been revoked `role`, emits a {RoleRevoked} * event. * * Requirements: * * - the caller must be `account`. * * May emit a {RoleRevoked} event. */ function renounceRole(bytes32 role, address account) public virtual override { require(account == _msgSender(), "AccessControl: can only renounce roles for self"); _revokeRole(role, account); } /** * @dev Grants `role` to `account`. * * If `account` had not been already granted `role`, emits a {RoleGranted} * event. Note that unlike {grantRole}, this function doesn't perform any * checks on the calling account. * * May emit a {RoleGranted} event. * * [WARNING] * ==== * This function should only be called from the constructor when setting * up the initial roles for the system. * * Using this function in any other way is effectively circumventing the admin * system imposed by {AccessControl}. * ==== * * NOTE: This function is deprecated in favor of {_grantRole}. */ function _setupRole(bytes32 role, address account) internal virtual { _grantRole(role, account); } /** * @dev Sets `adminRole` as ``role``'s admin role. * * Emits a {RoleAdminChanged} event. */ function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual { bytes32 previousAdminRole = getRoleAdmin(role); _roles[role].adminRole = adminRole; emit RoleAdminChanged(role, previousAdminRole, adminRole); } /** * @dev Grants `role` to `account`. * * Internal function without access restriction. * * May emit a {RoleGranted} event. */ function _grantRole(bytes32 role, address account) internal virtual { if (!hasRole(role, account)) { _roles[role].members[account] = true; emit RoleGranted(role, account, _msgSender()); } } /** * @dev Revokes `role` from `account`. * * Internal function without access restriction. * * May emit a {RoleRevoked} event. */ function _revokeRole(bytes32 role, address account) internal virtual { if (hasRole(role, account)) { _roles[role].members[account] = false; emit RoleRevoked(role, account, _msgSender()); } } } // File: contracts/HypeAliensGenesis.sol //@author PZ //@title HypeAliens pragma solidity 0.8.17; contract HypeAliensGenesis is ERC721Enumerable, IERC721Receiver,VRFConsumerBaseV2, ReentrancyGuard, Ownable,ERC2981,DefaultOperatorFilterer{ using Strings for uint256; using Counters for Counters.Counter; using EnumerableSet for EnumerableSet.UintSet; bool public transformActive; string private baseUri; //0:baseurl;1:galaxycoin ;2:gold2galaxy;3:goldcoin;4:normal2gold;5:normalcoin mapping(uint256=>string) private baseUrlMap; mapping(uint256=>bool) private coinIdMap; mapping(uint256=>uint256) private requestIdMap; mapping(uint256=>uint256) private luckyCoinMap; mapping(uint256=>uint256) private normalCoinMap; mapping(uint256=>uint256) private normal2GoldMap; mapping(uint256=>uint256) private goldCoinMap; mapping(uint256=>uint256) private gold2GalaxyMap; mapping(uint256=>uint256) private galaxyCoinMap; Counters.Counter private normal_Coin; Counters.Counter private normal_2_Gold; Counters.Counter private gold_Coin; Counters.Counter private gold_2_Galaxy; Counters.Counter private galaxy_Coin; IERC721 immutable HYPE_SAINTS; IERC1155 immutable HYPE_GEAR; ICoin immutable HYPE_COIN; uint256 public constant COIN_ID = 0; uint256 public constant DEFORMABLE_ALIEN = 3333; uint256 public constant NORMAL_COIN = 100; //100 uint256 public constant NORMAL2GOLD = 10; //10 uint256 public constant GOLD_COIN = 10; //10 uint256 public constant GOLD2GALAXY = 2; //2 EnumerableSet.UintSet private goldHS; EnumerableSet.UintSet private galaxyHS; uint256[10] public RAMDOM = [0,0,0,0,0,0,1,0,0,0]; //[0,0,0,0,0,0,1,0,0,0] VRFCoordinatorV2Interface immutable COORDINATOR; LinkTokenInterface immutable LINKTOKEN; struct RequestConfig { bytes32 keyHash; uint64 subId; uint32 callbackGasLimit; uint16 requestConfirmations; } RequestConfig public requestConfig; modifier tokenExists(uint256 tokenId) { require(_exists(tokenId), "Token does not exist."); _; } modifier callerIsUser() { require(tx.origin == msg.sender, "The caller is another contract"); _; } constructor(address _Saints, address _coin, address _gear, address _VRFCoordinator, address _LINKToken) ERC721("HypeAliensGenesis", "HAG") VRFConsumerBaseV2(_VRFCoordinator) { HYPE_SAINTS = IERC721(_Saints); HYPE_COIN = ICoin(_coin); HYPE_GEAR = IERC1155(_gear); COORDINATOR = VRFCoordinatorV2Interface(_VRFCoordinator); LINKTOKEN = LinkTokenInterface(_LINKToken); } function setBaseURIMap(string memory uri,uint256 id) external onlyOwner { baseUrlMap[id] = uri; } function getBaseURIMap(uint256 id) public view onlyOwner returns (string memory) { return baseUrlMap[id]; } function setBaseURI(string memory _baseUri) external onlyOwner { baseUri = _baseUri; } function setTransformActive(bool _transformActive) external onlyOwner { transformActive = _transformActive; } function getCoinMap(uint256 tokenId) public view onlyOwner returns (bool) { return coinIdMap[tokenId]; } //get goldHS function getGoldHS() public view returns (uint256[] memory) { return goldHS.values(); } //set goldHS function setGoldHS(uint256[] memory _goldHS) public onlyOwner { for(uint256 i = 0; i < _goldHS.length; i++) { goldHS.add(_goldHS[i]); } } //get galaxyHS function getGalaxyHS() public view returns (uint256[] memory) { return galaxyHS.values(); } //set galaxyHS function setGalaxyHS(uint256[] memory _galaxyHS) public onlyOwner { for(uint256 i = 0; i < _galaxyHS.length; i++) { galaxyHS.add(_galaxyHS[i]); } } function setChainLinkConfig(uint64 _subId,bytes32 _keyHash,uint32 _callbackGasLimit,uint16 _requestConfirmations) external onlyOwner { requestConfig = RequestConfig({ keyHash: _keyHash, subId: _subId, callbackGasLimit: _callbackGasLimit, requestConfirmations: _requestConfirmations }); } function setSubId(uint64 _subId) external onlyOwner { requestConfig.subId = _subId; } function setCallbackGasLimit(uint32 _callbackGasLimit) external onlyOwner { requestConfig.callbackGasLimit = _callbackGasLimit; } function setRequestConfirmations(uint16 _requestConfirmations) external onlyOwner { requestConfig.requestConfirmations = _requestConfirmations; } function setKeyHash(bytes32 _keyHash) external onlyOwner { requestConfig.keyHash = _keyHash; } //0:baseurl;1:galaxycoin ;2:gold2galaxy;3:goldcoin;4:normal2gold;5:normalcoin function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "Token does not exist."); string memory baseURI = baseUrlMap[0]; if(galaxyCoinMap[tokenId] > 0) { baseURI = baseUrlMap[1]; return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, galaxyCoinMap[tokenId].toString())) : string(abi.encodePacked(baseUri, (tokenId%2).toString())); } if(gold2GalaxyMap[tokenId] > 0) { baseURI = baseUrlMap[2]; return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, gold2GalaxyMap[tokenId].toString())) : string(abi.encodePacked(baseUri, (tokenId%2).toString())); } if(goldCoinMap[tokenId] > 0) { baseURI = baseUrlMap[3]; return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, goldCoinMap[tokenId].toString())) : string(abi.encodePacked(baseUri, (tokenId%2).toString())); } if(normal2GoldMap[tokenId] > 0) { baseURI = baseUrlMap[4]; return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, normal2GoldMap[tokenId].toString())) : string(abi.encodePacked(baseUri, (tokenId%2).toString())); } if(normalCoinMap[tokenId] > 0) { baseURI = baseUrlMap[5]; return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, normalCoinMap[tokenId].toString())) : string(abi.encodePacked(baseUri, (tokenId%2).toString())); } return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : string(abi.encodePacked(baseUri, (tokenId%2).toString())); } function _createAlien(address to, uint256 tokenId) internal { _safeMint(to, tokenId); } function onERC721Received(address, address from, uint256 tokenId, bytes memory data) public virtual override nonReentrant returns (bytes4) { if (msg.sender == address(HYPE_SAINTS)) { require(transformActive, "Transform doesn't start."); if (!_exists(tokenId)) { _createAlien(from, tokenId); if(coinIdMap[tokenId]) { //burn hypecoin HYPE_COIN.burn(from,0,1); //galaxy use coin if(galaxyHS.contains(tokenId)) { galaxy_Coin.increment(); galaxyCoinMap[tokenId] = galaxy_Coin.current(); } else if (goldHS.contains(tokenId)) { //gold use coin if(RAMDOM[luckyCoinMap[tokenId]] == 1) { if(gold_2_Galaxy.current() + 1 <= GOLD2GALAXY) { gold_2_Galaxy.increment(); gold2GalaxyMap[tokenId] = gold_2_Galaxy.current(); } else { if(gold_Coin.current()+1 <= GOLD_COIN) { gold_Coin.increment(); goldCoinMap[tokenId] = gold_Coin.current(); } } } else { if(gold_Coin.current()+1 <= GOLD_COIN) { gold_Coin.increment(); goldCoinMap[tokenId] = gold_Coin.current(); } } } else{ //normal use coin if(RAMDOM[luckyCoinMap[tokenId]] == 1) { if(normal_2_Gold.current() + 1 <= NORMAL2GOLD) { normal_2_Gold.increment(); normal2GoldMap[tokenId] = normal_2_Gold.current(); } else { if(normal_Coin.current()+1 <= NORMAL_COIN) { normal_Coin.increment(); normalCoinMap[tokenId] = normal_Coin.current(); } } } else { if(normal_Coin.current()+1 <= NORMAL_COIN) { normal_Coin.increment(); normalCoinMap[tokenId] = normal_Coin.current(); } } } } } else { _safeTransfer(address(this), from, tokenId, ""); } } else if (msg.sender == address(this)) { require(transformActive, "Transform doesn't start."); HYPE_SAINTS.safeTransferFrom(address(this), from, tokenId); } else { revert("Only HypeSaints and HypeAliens are supported."); } return this.onERC721Received.selector; } function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal override { uint256 luckyId = randomWords[0]%10; uint256 _tokenId = requestIdMap[requestId]; luckyCoinMap[_tokenId] = luckyId; address hsOwner = HYPE_SAINTS.ownerOf(_tokenId); HYPE_SAINTS.safeTransferFrom(hsOwner, address(this), _tokenId, "Transform to HypeAlien"); } //1.use coin or not //2.it's normal or gold or galaxy //3. normal and gold can upgrade,need to use chainlink, function transformAlien(uint256 hypeSaintId,bool useCoin,uint256 gearId) external callerIsUser { require(transformActive, "Transform doesn't start."); //need hypegear require(HYPE_GEAR.balanceOf(msg.sender, gearId) > 0,"You don't have this HypeGear."); require(msg.sender == HYPE_SAINTS.ownerOf(hypeSaintId),"You don't own this HypeSaint."); if (useCoin) { require(!_exists(hypeSaintId),"This HypeSaint is not the first time to transform, so you can not use HypeCoin"); require(HYPE_COIN.balanceOf(msg.sender, COIN_ID) > 0,"This address does not have HypeCoin"); coinIdMap[hypeSaintId] = true; if (!galaxyHS.contains(hypeSaintId)&&!goldHS.contains(hypeSaintId)&&normal_Coin.current()<NORMAL_COIN) { RequestConfig memory rc = requestConfig; uint256 requestId = COORDINATOR.requestRandomWords(rc.keyHash, rc.subId, rc.requestConfirmations, rc.callbackGasLimit, 1); requestIdMap[requestId] = hypeSaintId; }else if (goldHS.contains(hypeSaintId)&&gold_Coin.current()<GOLD_COIN) { RequestConfig memory rc = requestConfig; uint256 requestId = COORDINATOR.requestRandomWords(rc.keyHash, rc.subId, rc.requestConfirmations, rc.callbackGasLimit, 1); requestIdMap[requestId] = hypeSaintId; } else { HYPE_SAINTS.safeTransferFrom(msg.sender, address(this), hypeSaintId, "Transform to HypeAlien"); } } else { HYPE_SAINTS.safeTransferFrom(msg.sender, address(this), hypeSaintId, "Transform to HypeAlien"); } } function transformSaints(uint256 _alienId,uint256 gearId) external callerIsUser { require(transformActive, "Transform doesn't start."); //need hypegear require(HYPE_GEAR.balanceOf(msg.sender, gearId) > 0,"You don't have this HypeGear."); require(msg.sender == ownerOf(_alienId),"You don't own this HypeAlien."); safeTransferFrom(msg.sender, address(this), _alienId); } function supportsInterface(bytes4 interfaceId) public view override(ERC2981,ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } //set Default Royalty._feeNumerator 500 = 5% Royalty function setDefaultRoyalty(address _receiver, uint96 _feeNumerator) external virtual onlyOwner { _setDefaultRoyalty(_receiver, _feeNumerator); } /** * @notice Set the state of the OpenSea operator filter * @param value Flag indicating if the operator filter should be applied to transfers and approvals */ function setOperatorFilteringEnabled(bool value) external onlyOwner { operatorFilteringEnabled = value; } function setApprovalForAll(address operator, bool approved) public override(ERC721,IERC721) onlyAllowedOperatorApproval(operator) { super.setApprovalForAll(operator, approved); } function approve(address operator, uint256 tokenId) public override(ERC721,IERC721) onlyAllowedOperatorApproval(operator) { super.approve(operator, tokenId); } function transferFrom(address from, address to, uint256 tokenId) public override(ERC721,IERC721) onlyAllowedOperator(from) { super.transferFrom(from, to, tokenId); } function safeTransferFrom(address from, address to, uint256 tokenId) public override(ERC721,IERC721) onlyAllowedOperator(from) { super.safeTransferFrom(from, to, tokenId); } function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public override(ERC721,IERC721) onlyAllowedOperator(from) { super.safeTransferFrom(from, to, tokenId, data); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"address","name":"_Saints","type":"address"},{"internalType":"address","name":"_coin","type":"address"},{"internalType":"address","name":"_gear","type":"address"},{"internalType":"address","name":"_VRFCoordinator","type":"address"},{"internalType":"address","name":"_LINKToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"have","type":"address"},{"internalType":"address","name":"want","type":"address"}],"name":"OnlyCoordinatorCanFulfill","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":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":"COIN_ID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFORMABLE_ALIEN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GOLD2GALAXY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GOLD_COIN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NORMAL2GOLD","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NORMAL_COIN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"RAMDOM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"getBaseURIMap","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getCoinMap","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGalaxyHS","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getGoldHS","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"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":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"operatorFilteringEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"requestId","type":"uint256"},{"internalType":"uint256[]","name":"randomWords","type":"uint256[]"}],"name":"rawFulfillRandomWords","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"requestConfig","outputs":[{"internalType":"bytes32","name":"keyHash","type":"bytes32"},{"internalType":"uint64","name":"subId","type":"uint64"},{"internalType":"uint32","name":"callbackGasLimit","type":"uint32"},{"internalType":"uint16","name":"requestConfirmations","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseUri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"setBaseURIMap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"_callbackGasLimit","type":"uint32"}],"name":"setCallbackGasLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_subId","type":"uint64"},{"internalType":"bytes32","name":"_keyHash","type":"bytes32"},{"internalType":"uint32","name":"_callbackGasLimit","type":"uint32"},{"internalType":"uint16","name":"_requestConfirmations","type":"uint16"}],"name":"setChainLinkConfig","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_receiver","type":"address"},{"internalType":"uint96","name":"_feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_galaxyHS","type":"uint256[]"}],"name":"setGalaxyHS","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_goldHS","type":"uint256[]"}],"name":"setGoldHS","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_keyHash","type":"bytes32"}],"name":"setKeyHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"value","type":"bool"}],"name":"setOperatorFilteringEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint16","name":"_requestConfirmations","type":"uint16"}],"name":"setRequestConfirmations","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_subId","type":"uint64"}],"name":"setSubId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_transformActive","type":"bool"}],"name":"setTransformActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"transformActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"hypeSaintId","type":"uint256"},{"internalType":"bool","name":"useCoin","type":"bool"},{"internalType":"uint256","name":"gearId","type":"uint256"}],"name":"transformAlien","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_alienId","type":"uint256"},{"internalType":"uint256","name":"gearId","type":"uint256"}],"name":"transformSaints","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)
0000000000000000000000004af790223169a8621095871375f79425725d22c9000000000000000000000000509a4d150036fe9b0cb83594d44bdd21ad8cfdf20000000000000000000000007851cf4f9808fd4389cc5c7c13f4ced86fb301a5000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909000000000000000000000000514910771af9ca656af840dff83e8264ecf986ca
-----Decoded View---------------
Arg [0] : _Saints (address): 0x4aF790223169a8621095871375f79425725d22C9
Arg [1] : _coin (address): 0x509A4d150036fE9b0Cb83594D44BdD21AD8CFdf2
Arg [2] : _gear (address): 0x7851Cf4F9808FD4389Cc5c7c13F4CeD86Fb301a5
Arg [3] : _VRFCoordinator (address): 0x271682DEB8C4E0901D1a1550aD2e64D568E69909
Arg [4] : _LINKToken (address): 0x514910771AF9Ca656af840dff83E8264EcF986CA
-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000004af790223169a8621095871375f79425725d22c9
Arg [1] : 000000000000000000000000509a4d150036fe9b0cb83594d44bdd21ad8cfdf2
Arg [2] : 0000000000000000000000007851cf4f9808fd4389cc5c7c13f4ced86fb301a5
Arg [3] : 000000000000000000000000271682deb8c4e0901d1a1550ad2e64d568e69909
Arg [4] : 000000000000000000000000514910771af9ca656af840dff83e8264ecf986ca
Deployed Bytecode Sourcemap
115516:15082:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;128873:171;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;128873:171:0;;;;;;;;119271:105;;;:::i;:::-;;;;;;;:::i;129110:158::-;;;;;;:::i;:::-;;:::i;:::-;;117021:39;;117059:1;117021:39;;;;;1951:25:1;;;1939:2;1924:18;117021:39:0;1805:177:1;84658:100:0;;;:::i;:::-;;;;;;;:::i;86171:171::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;3092:32:1;;;3074:51;;3062:2;3047:18;86171:171:0;2928:203:1;129788:173:0;;;;;;:::i;:::-;;:::i;116864:41::-;;116902:3;116864:41;;122474:3147;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;;5240:33:1;;;5222:52;;5210:2;5195:18;122474:3147:0;5078:202:1;98564:113:0;98652:10;:17;98564:113;;17358:261;;;;;;:::i;:::-;;:::i;118427:121::-;;;;;;:::i;:::-;;:::i;129969:179::-;;;;;;:::i;:::-;;:::i;73737:442::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;7329:32:1;;;7311:51;;7393:2;7378:18;;7371:34;;;;7284:18;73737:442:0;7137:274:1;98232:256:0;;;;;;:::i;:::-;;:::i;117171:50::-;;;;;;:::i;:::-;;:::i;119969:99::-;;;;;;:::i;:::-;;:::i;7724:143::-;;132:42;7724:143;;130156:187;;;;;;:::i;:::-;;:::i;98754:233::-;;;;;;:::i;:::-;;:::i;117509:34::-;;;;;;;;-1:-1:-1;;;;;117509:34:0;;;-1:-1:-1;;;117509:34:0;;;;;-1:-1:-1;;;117509:34:0;;;;;;;;;;8245:25:1;;;-1:-1:-1;;;;;8306:31:1;;;8301:2;8286:18;;8279:59;8386:10;8374:23;;;8354:18;;;8347:51;;;;8446:6;8434:19;8429:2;8414:18;;8407:47;8232:3;8217:19;117509:34:0;8020:440:1;126199:2226:0;;;;;;:::i;:::-;;:::i;118560:100::-;;;;;;:::i;:::-;;:::i;84369:222::-;;;;;;:::i;:::-;;:::i;84100:207::-;;;;;;:::i;:::-;;:::i;81507:103::-;;;:::i;119599:362::-;;;;;;:::i;:::-;;:::i;120227:159::-;;;;;;:::i;:::-;;:::i;80859:87::-;80932:6;;-1:-1:-1;;;;;80932:6:0;80859:87;;84827:104;;;:::i;120394:108::-;;;;;;:::i;:::-;;:::i;116768:35::-;;116802:1;116768:35;;116970:38;;117006:2;116970:38;;129588:192;;;;;;:::i;:::-;;:::i;120076:143::-;;;;;;:::i;:::-;;:::i;119070:173::-;;;;;;:::i;:::-;;:::i;115795:27::-;;;;;;;;;;;;118943:101;;;:::i;129461:119::-;;;;;;:::i;:::-;;:::i;130351:244::-;;;;;;:::i;:::-;;:::i;118308:111::-;;;;;;:::i;:::-;;:::i;120593:1762::-;;;;;;:::i;:::-;;:::i;128443:422::-;;;;;;:::i;:::-;;:::i;119404:187::-;;;;;;:::i;:::-;;:::i;118799:118::-;;;;;;:::i;:::-;;:::i;86640:164::-;;;;;;:::i;:::-;-1:-1:-1;;;;;86761:25:0;;;86737:4;86761:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;86640:164;116810:47;;116853:4;116810:47;;118668:123;;;;;;:::i;:::-;;:::i;81765:201::-;;;;;;:::i;:::-;;:::i;7672:43::-;;;;;;;;;128873:171;128976:4;129000:36;129024:11;129000:23;:36::i;:::-;128993:43;128873:171;-1:-1:-1;;128873:171:0:o;119271:105::-;119315:16;119351:17;:8;:15;:17::i;:::-;119344:24;;119271:105;:::o;129110:158::-;80745:13;:11;:13::i;:::-;129216:44:::1;129235:9;129246:13;129216:18;:44::i;:::-;129110:158:::0;;:::o;84658:100::-;84712:13;84745:5;84738:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;84658:100;:::o;86171:171::-;86247:7;86267:23;86282:7;86267:14;:23::i;:::-;-1:-1:-1;86310:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;86310:24:0;;86171:171::o;129788:173::-;129900:8;132:42;9828:45;:49;;;;:77;;-1:-1:-1;9881:24:0;;;;9828:77;9824:253;;;9927:67;;-1:-1:-1;;;9927:67:0;;9978:4;9927:67;;;13443:34:1;-1:-1:-1;;;;;13513:15:1;;13493:18;;;13486:43;132:42:0;;9927;;13378:18:1;;9927:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9922:144;;10022:28;;-1:-1:-1;;;10022:28:0;;-1:-1:-1;;;;;3092:32:1;;10022:28:0;;;3074:51:1;3047:18;;10022:28:0;;;;;;;;9922:144;129921:32:::1;129935:8;129945:7;129921:13;:32::i;:::-;129788:173:::0;;;:::o;122474:3147::-;122605:6;47257:1;47855:7;;:19;47847:63;;;;-1:-1:-1;;;47847:63:0;;13992:2:1;47847:63:0;;;13974:21:1;14031:2;14011:18;;;14004:30;14070:33;14050:18;;;14043:61;14121:18;;47847:63:0;13790:355:1;47847:63:0;47257:1;47988:7;:18;-1:-1:-1;;;;;122650:11:0::1;122628:34;:10;:34:::0;122624:2940:::1;;122687:15;::::0;::::1;::::0;::::1;;;122679:52;;;;-1:-1:-1::0;;;122679:52:0::1;;;;;;;:::i;:::-;89429:4:::0;89453:16;;;:7;:16;;;;;;-1:-1:-1;;;;;89453:16:0;122748:2526:::1;;122790:27;122803:4;122809:7;122790:12;:27::i;:::-;122839:18;::::0;;;:9:::1;:18;::::0;;;;;::::1;;122836:2335;;;122919:24;::::0;-1:-1:-1;;;122919:24:0;;-1:-1:-1;;;;;14739:32:1;;;122919:24:0::1;::::0;::::1;14721:51:1::0;122939:1:0::1;14788:18:1::0;;;14781:34;122941:1:0::1;14831:18:1::0;;;14824:34;122919:9:0::1;:14;::::0;::::1;::::0;14694:18:1;;122919:24:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;123008:26;123026:7;123008:8;:17;;:26;;;;:::i;:::-;123005:2147;;;123063:23;:11;38022:19:::0;;38040:1;38022:19;;;37933:127;123063:23:::1;123138:11;37903:14:::0;123113:22:::1;::::0;;;:13:::1;:22;::::0;;;;:46;122624:2940:::1;;123005:2147;123193:24;:6;123209:7:::0;123193:15:::1;:24::i;:::-;123189:1963;;;123274:21;::::0;;;:12:::1;:21;::::0;;;;;123267:6:::1;::::0;:29:::1;::::0;::::1;;;;;:::i;:::-;;;123300:1;123267:34:::0;123264:888:::1;;117059:1;123337:23;:13;37903:14:::0;;37811:114;123337:23:::1;:27;::::0;123363:1:::1;123337:27;:::i;:::-;:42;123334:511;;123416:25;:13;38022:19:::0;;38040:1;38022:19;;;37933:127;123416:25:::1;123502:13;37903:14:::0;123476:23:::1;::::0;;;:14:::1;:23;::::0;;;;:49;122624:2940:::1;;123334:511;117006:2;123601:19;:9;37903:14:::0;;37811:114;123601:19:::1;:21;::::0;123621:1:::1;123601:21;:::i;:::-;:34;123598:216;;123676:21;:9;38022:19:::0;;38040:1;38022:19;;;37933:127;123676:21:::1;123759:9;37903:14:::0;123736:20:::1;::::0;;;:11:::1;:20;::::0;;;;:42;123598:216:::1;122624:2940;;123189:1963;124235:21;::::0;;;:12:::1;:21;::::0;;;;;124228:6:::1;::::0;:29:::1;::::0;::::1;;;;;:::i;:::-;;;124261:1;124228:34:::0;124225:904:::1;;116956:2;124298:23;:13;37903:14:::0;;37811:114;124298:23:::1;:27;::::0;124324:1:::1;124298:27;:::i;:::-;:42;124295:521;;124377:25;:13;38022:19:::0;;38040:1;38022:19;;;37933:127;124377:25:::1;124463:13;37903:14:::0;124437:23:::1;::::0;;;:14:::1;:23;::::0;;;;:49;122624:2940:::1;;124295:521;116902:3;124562:21;:11;37903:14:::0;;37811:114;124562:21:::1;:23;::::0;124584:1:::1;124562:23;:::i;:::-;:38;124559:226;;124641:23;:11;38022:19:::0;;38040:1;38022:19;;;37933:127;124641:23:::1;124728:11;37903:14:::0;124703:22:::1;::::0;;;:13:::1;:22;::::0;;;;:46;122624:2940:::1;;122748:2526;125211:47;125233:4;125240;125246:7;125211:47;;;;;;;;;;;::::0;:13:::1;:47::i;122624:2940::-;125317:4;125295:10;:27:::0;125291:273:::1;;125347:15;::::0;::::1;::::0;::::1;;;125339:52;;;;-1:-1:-1::0;;;125339:52:0::1;;;;;;;:::i;:::-;125406:58;::::0;-1:-1:-1;;;125406:58:0;;125443:4:::1;125406:58;::::0;::::1;15503:34:1::0;-1:-1:-1;;;;;15573:15:1;;;15553:18;;;15546:43;15605:18;;;15598:34;;;125406:11:0::1;:28;::::0;::::1;::::0;15438:18:1;;125406:58:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;125291:273;;;125497:55;::::0;-1:-1:-1;;;125497:55:0;;15845:2:1;125497:55:0::1;::::0;::::1;15827:21:1::0;15884:2;15864:18;;;15857:30;15923:34;15903:18;;;15896:62;-1:-1:-1;;;15974:18:1;;;15967:43;16027:19;;125497:55:0::1;15643:409:1::0;125291:273:0::1;-1:-1:-1::0;;;;47213:1:0;48167:7;:22;122474:3147;;-1:-1:-1;;;;122474:3147:0:o;17358:261::-;17458:10;-1:-1:-1;;;;;17472:14:0;17458:28;;17454:111;;17504:53;;-1:-1:-1;;;17504:53:0;;17530:10;17504:53;;;13443:34:1;-1:-1:-1;;;;;17542:14:0;13513:15:1;13493:18;;;13486:43;13378:18;;17504:53:0;13231:304:1;17454:111:0;17571:42;17590:9;17601:11;17571:18;:42::i;118427:121::-;118493:13;80745;:11;:13::i;:::-;118526:14:::1;::::0;;;:10:::1;:14;::::0;;;;118519:21;;::::1;::::0;::::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80769:1;118427:121:::0;;;:::o;129969:179::-;130086:4;132:42;9054:45;:49;;;;:77;;-1:-1:-1;9107:24:0;;;;9054:77;9050:567;;;9371:10;-1:-1:-1;;;;;9363:18:0;;;9359:85;;130103:37:::1;130122:4;130128:2;130132:7;130103:18;:37::i;:::-;9422:7:::0;;9359:85;9463:69;;-1:-1:-1;;;9463:69:0;;9514:4;9463:69;;;13443:34:1;9521:10:0;13493:18:1;;;13486:43;132:42:0;;9463;;13378:18:1;;9463:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9458:148;;9560:30;;-1:-1:-1;;;9560:30:0;;9579:10;9560:30;;;3074:51:1;3047:18;;9560:30:0;2928:203:1;9458:148:0;130103:37:::1;130122:4;130128:2;130132:7;130103:18;:37::i;:::-;129969:179:::0;;;;:::o;73737:442::-;73834:7;73892:27;;;:17;:27;;;;;;;;73863:56;;;;;;;;;-1:-1:-1;;;;;73863:56:0;;;;;-1:-1:-1;;;73863:56:0;;;-1:-1:-1;;;;;73863:56:0;;;;;;;;73834:7;;73932:92;;-1:-1:-1;73983:29:0;;;;;;;;;73993:19;73983:29;-1:-1:-1;;;;;73983:29:0;;;;-1:-1:-1;;;73983:29:0;;-1:-1:-1;;;;;73983:29:0;;;;;73932:92;74074:23;;;;74036:21;;74545:5;;74061:36;;-1:-1:-1;;;;;74061:36:0;:10;:36;:::i;:::-;74060:58;;;;:::i;:::-;74139:16;;;;;-1:-1:-1;73737:442:0;;-1:-1:-1;;;;73737:442:0:o;98232:256::-;98329:7;98365:23;98382:5;98365:16;:23::i;:::-;98357:5;:31;98349:87;;;;-1:-1:-1;;;98349:87:0;;16689:2:1;98349:87:0;;;16671:21:1;16728:2;16708:18;;;16701:30;16767:34;16747:18;;;16740:62;-1:-1:-1;;;16818:18:1;;;16811:41;16869:19;;98349:87:0;16487:407:1;98349:87:0;-1:-1:-1;;;;;;98454:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;98232:256::o;117171:50::-;;;;;;;;;;;;;;;-1:-1:-1;117171:50:0;:::o;119969:99::-;80745:13;:11;:13::i;:::-;120032:19;:28;;-1:-1:-1;;120032:28:0::1;-1:-1:-1::0;;;;;120032:28:0;;;::::1;::::0;;;::::1;::::0;;119969:99::o;130156:187::-;130277:4;132:42;9054:45;:49;;;;:77;;-1:-1:-1;9107:24:0;;;;9054:77;9050:567;;;9371:10;-1:-1:-1;;;;;9363:18:0;;;9359:85;;130294:41:::1;130317:4;130323:2;130327:7;130294:22;:41::i;9359:85::-:0;9463:69;;-1:-1:-1;;;9463:69:0;;9514:4;9463:69;;;13443:34:1;9521:10:0;13493:18:1;;;13486:43;132:42:0;;9463;;13378:18:1;;9463:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9458:148;;9560:30;;-1:-1:-1;;;9560:30:0;;9579:10;9560:30;;;3074:51:1;3047:18;;9560:30:0;2928:203:1;9458:148:0;130294:41:::1;130317:4;130323:2;130327:7;130294:22;:41::i;98754:233::-:0;98829:7;98865:30;98652:10;:17;;98564:113;98865:30;98857:5;:38;98849:95;;;;-1:-1:-1;;;98849:95:0;;17101:2:1;98849:95:0;;;17083:21:1;17140:2;17120:18;;;17113:30;17179:34;17159:18;;;17152:62;-1:-1:-1;;;17230:18:1;;;17223:42;17282:19;;98849:95:0;16899:408:1;98849:95:0;98962:10;98973:5;98962:17;;;;;;;;:::i;:::-;;;;;;;;;98955:24;;98754:233;;;:::o;126199:2226::-;117722:9;117735:10;117722:23;117714:66;;;;-1:-1:-1;;;117714:66:0;;17514:2:1;117714:66:0;;;17496:21:1;17553:2;17533:18;;;17526:30;17592:32;17572:18;;;17565:60;17642:18;;117714:66:0;17312:354:1;117714:66:0;126315:15:::1;::::0;::::1;::::0;::::1;;;126307:52;;;;-1:-1:-1::0;;;126307:52:0::1;;;;;;;:::i;:::-;126403:39;::::0;-1:-1:-1;;;126403:39:0;;126423:10:::1;126403:39;::::0;::::1;7311:51:1::0;7378:18;;;7371:34;;;126445:1:0::1;::::0;126403:9:::1;-1:-1:-1::0;;;;;126403:19:0::1;::::0;::::1;::::0;7284:18:1;;126403:39:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:43;126395:84;;;::::0;-1:-1:-1;;;126395:84:0;;18062:2:1;126395:84:0::1;::::0;::::1;18044:21:1::0;18101:2;18081:18;;;18074:30;18140:31;18120:18;;;18113:59;18189:18;;126395:84:0::1;17860:353:1::0;126395:84:0::1;126514:32;::::0;-1:-1:-1;;;126514:32:0;;::::1;::::0;::::1;1951:25:1::0;;;126514:11:0::1;-1:-1:-1::0;;;;;126514:19:0::1;::::0;::::1;::::0;1924:18:1;;126514:32:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;126500:46:0::1;:10;-1:-1:-1::0;;;;;126500:46:0::1;;126492:87;;;::::0;-1:-1:-1;;;126492:87:0;;18676:2:1;126492:87:0::1;::::0;::::1;18658:21:1::0;18715:2;18695:18;;;18688:30;18754:31;18734:18;;;18727:59;18803:18;;126492:87:0::1;18474:353:1::0;126492:87:0::1;126596:7;126592:1812;;;89429:4:::0;89453:16;;;:7;:16;;;;;;-1:-1:-1;;;;;89453:16:0;:30;126620:111:::1;;;::::0;-1:-1:-1;;;126620:111:0;;19034:2:1;126620:111:0::1;::::0;::::1;19016:21:1::0;19073:2;19053:18;;;19046:30;19112:34;19092:18;;;19085:62;19183:34;19163:18;;;19156:62;-1:-1:-1;;;19234:19:1;;;19227:45;19289:19;;126620:111:0::1;18832:482:1::0;126620:111:0::1;126754:40;::::0;-1:-1:-1;;;126754:40:0;;126774:10:::1;126754:40;::::0;::::1;7311:51:1::0;126797:1:0::1;7378:18:1::0;;;7371:34;;;126797:1:0;126754:9:::1;-1:-1:-1::0;;;;;126754:19:0::1;::::0;::::1;::::0;7284:18:1;;126754:40:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;126746:91;;;::::0;-1:-1:-1;;;126746:91:0;;19521:2:1;126746:91:0::1;::::0;::::1;19503:21:1::0;19560:2;19540:18;;;19533:30;19599:34;19579:18;;;19572:62;-1:-1:-1;;;19650:18:1;;;19643:33;19693:19;;126746:91:0::1;19319:399:1::0;126746:91:0::1;126852:22;::::0;;;:9:::1;:22;::::0;;;;;;;:29;;-1:-1:-1;;126852:29:0::1;126877:4;126852:29;::::0;;126903:30:::1;::::0;126862:11;126903:17:::1;:30::i;:::-;126902:31;:62;;;;-1:-1:-1::0;126936:28:0::1;:6;126952:11:::0;126936:15:::1;:28::i;:::-;126935:29;126902:62;:97;;;;;116902:3;126966:21;:11;37903:14:::0;;37811:114;126966:21:::1;:33;126902:97;126898:1368;;;127020:39;::::0;;::::1;::::0;::::1;::::0;;127046:13:::1;127020:39:::0;;;;;;-1:-1:-1;;;;;127020:39:0;::::1;;::::0;::::1;::::0;;;-1:-1:-1;;;127020:39:0;::::1;;;::::0;;;;;;-1:-1:-1;;;127020:39:0;;::::1;;;::::0;;;;;;127098:361;;-1:-1:-1;;;127098:361:0;;::::1;::::0;::::1;19983:25:1::0;;;;20024:18;;;20017:59;20092:18;;;20085:47;;;;20177:18;;;20170:43;;;;127020:39:0::1;20229:19:1::0;;;20222:44;127020:39:0;-1:-1:-1;;127098:11:0::1;-1:-1:-1::0;;;;;127098:30:0::1;::::0;::::1;::::0;19955:19:1;;127098:361:0::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;127478:23;::::0;;;:12:::1;:23;::::0;;;;:37;;;-1:-1:-1;126592:1812:0::1;::::0;-1:-1:-1;126592:1812:0::1;126898:1368;127540:28;:6;127556:11:::0;127540:15:::1;:28::i;:::-;:59;;;;;117006:2;127570:19;:9;37903:14:::0;;37811:114;127570:19:::1;:29;127540:59;127536:730;;;127620:39;::::0;;::::1;::::0;::::1;::::0;;127646:13:::1;127620:39:::0;;;;;;-1:-1:-1;;;;;127620:39:0;::::1;;::::0;::::1;::::0;;;-1:-1:-1;;;127620:39:0;::::1;;;::::0;;;;;;-1:-1:-1;;;127620:39:0;;::::1;;;::::0;;;;;;127698:361;;-1:-1:-1;;;127698:361:0;;::::1;::::0;::::1;19983:25:1::0;;;;20024:18;;;20017:59;20092:18;;;20085:47;;;;20177:18;;;20170:43;;;;127620:39:0::1;20229:19:1::0;;;20222:44;127620:39:0;-1:-1:-1;;127698:11:0::1;-1:-1:-1::0;;;;;127698:30:0::1;::::0;::::1;::::0;19955:19:1;;127698:361:0::1;19723:549:1::0;127536:730:0::1;128156:94;::::0;-1:-1:-1;;;128156:94:0;;-1:-1:-1;;;;;128156:11:0::1;:28;::::0;::::1;::::0;:94:::1;::::0;128185:10:::1;::::0;128205:4:::1;::::0;128212:11;;128156:94:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;129788:173:::0;;;:::o;118560:100::-;80745:13;:11;:13::i;:::-;118634:7:::1;:18;118644:8:::0;118634:7;:18:::1;:::i;84369:222::-:0;84441:7;84477:16;;;:7;:16;;;;;;-1:-1:-1;;;;;84477:16:0;;84504:56;;;;-1:-1:-1;;;84504:56:0;;23306:2:1;84504:56:0;;;23288:21:1;23345:2;23325:18;;;23318:30;-1:-1:-1;;;23364:18:1;;;23357:54;23428:18;;84504:56:0;23104:348:1;84100:207:0;84172:7;-1:-1:-1;;;;;84200:19:0;;84192:73;;;;-1:-1:-1;;;84192:73:0;;23659:2:1;84192:73:0;;;23641:21:1;23698:2;23678:18;;;23671:30;23737:34;23717:18;;;23710:62;-1:-1:-1;;;23788:18:1;;;23781:39;23837:19;;84192:73:0;23457:405:1;84192:73:0;-1:-1:-1;;;;;;84283:16:0;;;;;:9;:16;;;;;;;84100:207::o;81507:103::-;80745:13;:11;:13::i;:::-;81572:30:::1;81599:1;81572:18;:30::i;:::-;81507:103::o:0;119599:362::-;80745:13;:11;:13::i;:::-;119759:194:::1;::::0;;::::1;::::0;::::1;::::0;;;;;-1:-1:-1;;;;;119759:194:0;;::::1;;::::0;::::1;::::0;;;::::1;::::0;;::::1;::::0;;;;;;::::1;::::0;;::::1;::::0;;;;;;;119743:13:::1;:210:::0;;;;;;;-1:-1:-1;;;119743:210:0;;::::1;-1:-1:-1::0;;;;;;;119743:210:0;;::::1;-1:-1:-1::0;;119743:210:0;;;;;;;;;::::1;::::0;;;::::1;;::::0;;119599:362::o;120227:159::-;80745:13;:11;:13::i;:::-;120320:34;:58;;::::1;::::0;;::::1;-1:-1:-1::0;;;120320:58:0::1;-1:-1:-1::0;;;;120320:58:0;;::::1;::::0;;;::::1;::::0;;120227:159::o;84827:104::-;84883:13;84916:7;84909:14;;;;;:::i;120394:108::-;80745:13;:11;:13::i;:::-;120462::::1;:32:::0;120394:108::o;129588:192::-;129708:8;132:42;9828:45;:49;;;;:77;;-1:-1:-1;9881:24:0;;;;9828:77;9824:253;;;9927:67;;-1:-1:-1;;;9927:67:0;;9978:4;9927:67;;;13443:34:1;-1:-1:-1;;;;;13513:15:1;;13493:18;;;13486:43;132:42:0;;9927;;13378:18:1;;9927:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9922:144;;10022:28;;-1:-1:-1;;;10022:28:0;;-1:-1:-1;;;;;3092:32:1;;10022:28:0;;;3074:51:1;3047:18;;10022:28:0;2928:203:1;9922:144:0;129729:43:::1;129753:8;129763;129729:23;:43::i;120076:143::-:0;80745:13;:11;:13::i;:::-;120161:30;:50;;::::1;::::0;;::::1;-1:-1:-1::0;;;120161:50:0::1;-1:-1:-1::0;;120161:50:0;;::::1;::::0;;;::::1;::::0;;120076:143::o;119070:173::-;80745:13;:11;:13::i;:::-;119147:9:::1;119143:93;119166:7;:14;119162:1;:18;119143:93;;;119202:22;119213:7;119221:1;119213:10;;;;;;;;:::i;:::-;;;;;;;119202:6;:10;;:22;;;;:::i;:::-;-1:-1:-1::0;119182:3:0;::::1;::::0;::::1;:::i;:::-;;;;119143:93;;118943:101:::0;118985:16;119021:15;:6;:13;:15::i;129461:119::-;80745:13;:11;:13::i;:::-;129540:24:::1;:32:::0;;-1:-1:-1;;129540:32:0::1;::::0;::::1;;::::0;;;::::1;::::0;;129461:119::o;130351:244::-;130518:4;132:42;9054:45;:49;;;;:77;;-1:-1:-1;9107:24:0;;;;9054:77;9050:567;;;9371:10;-1:-1:-1;;;;;9363:18:0;;;9359:85;;130540:47:::1;130563:4;130569:2;130573:7;130582:4;130540:22;:47::i;:::-;9422:7:::0;;9359:85;9463:69;;-1:-1:-1;;;9463:69:0;;9514:4;9463:69;;;13443:34:1;9521:10:0;13493:18:1;;;13486:43;132:42:0;;9463;;13378:18:1;;9463:69:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9458:148;;9560:30;;-1:-1:-1;;;9560:30:0;;9579:10;9560:30;;;3074:51:1;3047:18;;9560:30:0;2928:203:1;9458:148:0;130540:47:::1;130563:4;130569:2;130573:7;130582:4;130540:22;:47::i;:::-;130351:244:::0;;;;;:::o;118308:111::-;80745:13;:11;:13::i;:::-;118391:14:::1;::::0;;;:10:::1;:14;::::0;;;;:20:::1;118408:3:::0;118391:14;:20:::1;:::i;120593:1762::-:0;89429:4;89453:16;;;:7;:16;;;;;;120666:13;;-1:-1:-1;;;;;89453:16:0;120692:50;;;;-1:-1:-1;;;120692:50:0;;24209:2:1;120692:50:0;;;24191:21:1;24248:2;24228:18;;;24221:30;-1:-1:-1;;;24267:18:1;;;24260:51;24328:18;;120692:50:0;24007:345:1;120692:50:0;120755:21;120779:13;;;:10;:13;;;120755:37;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;120833:1:0;120808:22;;;:13;:22;;;;;;120755:37;;-1:-1:-1;;120808:26:0;;;-1:-1:-1;120805:260:0;;120872:1;120861:13;;:10;:13;;;120851:23;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;120920:1;120902:7;120896:21;:25;:157;;121020:7;121029:22;121030:9;121038:1;121030:7;:9;:::i;:::-;121029:20;:22::i;:::-;121003:49;;;;;;;;;:::i;:::-;;;;;;;;;;;;;120896:157;;;120957:22;;;;:13;:22;;;;;;120948:7;;120957:33;;:31;:33::i;:::-;120931:60;;;;;;;;;:::i;:::-;;;;;;;;;;;;;120896:157;120889:164;120593:1762;-1:-1:-1;;;120593:1762:0:o;120805:260::-;121115:1;121089:23;;;:14;:23;;;;;;:27;121086:263;;121155:1;121144:13;;:10;:13;;;121134:23;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;121203:1;121185:7;121179:21;:25;:158;;121304:7;121313:22;121314:9;121322:1;121314:7;:9;:::i;121179:158::-;121240:23;;;;:14;:23;;;;;;121231:7;;121240:34;;:32;:34::i;121086:263::-;121388:1;121365:20;;;:11;:20;;;;;;:24;121362:256;;121427:1;121416:13;;:10;:13;;;121406:23;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;121475:1;121457:7;121451:21;:25;:155;;121573:7;121582:22;121583:9;121591:1;121583:7;:9;:::i;121451:155::-;121512:20;;;;:11;:20;;;;;;121503:7;;121512:31;;:29;:31::i;121362:256::-;121660:1;121634:23;;;:14;:23;;;;;;:27;121631:262;;121699:1;121688:13;;:10;:13;;;121678:23;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;121747:1;121729:7;121723:21;:25;:158;;121848:7;121857:22;121858:9;121866:1;121858:7;:9;:::i;121723:158::-;121784:23;;;;:14;:23;;;;;;121775:7;;121784:34;;:32;:34::i;121631:262::-;121934:1;121909:22;;;:13;:22;;;;;;:26;121906:260;;121973:1;121962:13;;:10;:13;;;121952:23;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;122021:1;122003:7;121997:21;:25;:157;;122121:7;122130:22;122131:9;122139:1;122131:7;:9;:::i;121997:157::-;122058:22;;;;:13;:22;;;;;;122049:7;;122058:33;;:31;:33::i;121906:260::-;122218:1;122200:7;122194:21;:25;:141;;122302:7;122311:22;122312:9;122320:1;122312:7;:9;:::i;122194:141::-;122246:7;122255:18;:7;:16;:18::i;128443:422::-;117722:9;117735:10;117722:23;117714:66;;;;-1:-1:-1;;;117714:66:0;;17514:2:1;117714:66:0;;;17496:21:1;17553:2;17533:18;;;17526:30;17592:32;17572:18;;;17565:60;17642:18;;117714:66:0;17312:354:1;117714:66:0;128542:15:::1;::::0;::::1;::::0;::::1;;;128534:52;;;;-1:-1:-1::0;;;128534:52:0::1;;;;;;;:::i;:::-;128630:39;::::0;-1:-1:-1;;;128630:39:0;;128650:10:::1;128630:39;::::0;::::1;7311:51:1::0;7378:18;;;7371:34;;;128672:1:0::1;::::0;128630:9:::1;-1:-1:-1::0;;;;;128630:19:0::1;::::0;::::1;::::0;7284:18:1;;128630:39:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:43;128622:84;;;::::0;-1:-1:-1;;;128622:84:0;;18062:2:1;128622:84:0::1;::::0;::::1;18044:21:1::0;18101:2;18081:18;;;18074:30;18140:31;18120:18;;;18113:59;18189:18;;128622:84:0::1;17860:353:1::0;128622:84:0::1;128741:17;128749:8;128741:7;:17::i;:::-;-1:-1:-1::0;;;;;128727:31:0::1;:10;-1:-1:-1::0;;;;;128727:31:0::1;;128719:72;;;::::0;-1:-1:-1;;;128719:72:0;;26202:2:1;128719:72:0::1;::::0;::::1;26184:21:1::0;26241:2;26221:18;;;26214:30;26280:31;26260:18;;;26253:59;26329:18;;128719:72:0::1;26000:353:1::0;128719:72:0::1;128804:53;128821:10;128841:4;128848:8;128804:16;:53::i;119404:187::-:0;80745:13;:11;:13::i;:::-;119485:9:::1;119481:103;119504:9;:16;119500:1;:20;119481:103;;;119542:26;119555:9;119565:1;119555:12;;;;;;;;:::i;:::-;;;;;;;119542:8;:12;;:26;;;;:::i;:::-;-1:-1:-1::0;119522:3:0;::::1;::::0;::::1;:::i;:::-;;;;119481:103;;118799:118:::0;118867:4;80745:13;:11;:13::i;:::-;-1:-1:-1;118891:18:0::1;::::0;;;:9:::1;:18;::::0;;;;;::::1;;::::0;118799:118::o;118668:123::-;80745:13;:11;:13::i;:::-;118749:15:::1;:34:::0;;;::::1;;;;-1:-1:-1::0;;118749:34:0;;::::1;::::0;;;::::1;::::0;;118668:123::o;81765:201::-;80745:13;:11;:13::i;:::-;-1:-1:-1;;;;;81854:22:0;::::1;81846:73;;;::::0;-1:-1:-1;;;81846:73:0;;26560:2:1;81846:73:0::1;::::0;::::1;26542:21:1::0;26599:2;26579:18;;;26572:30;26638:34;26618:18;;;26611:62;-1:-1:-1;;;26689:18:1;;;26682:36;26735:19;;81846:73:0::1;26358:402:1::0;81846:73:0::1;81930:28;81949:8;81930:18;:28::i;:::-;81765:201:::0;:::o;73467:215::-;73569:4;-1:-1:-1;;;;;;73593:41:0;;-1:-1:-1;;;73593:41:0;;:81;;;73638:36;73662:11;73638:23;:36::i;36625:307::-;36685:16;36714:22;36739:19;36747:3;36739:7;:19::i;81024:132::-;80932:6;;-1:-1:-1;;;;;80932:6:0;79490:10;81088:23;81080:68;;;;-1:-1:-1;;;81080:68:0;;26967:2:1;81080:68:0;;;26949:21:1;;;26986:18;;;26979:30;27045:34;27025:18;;;27018:62;27097:18;;81080:68:0;26765:356:1;74829:332:0;74545:5;-1:-1:-1;;;;;74932:33:0;;;;74924:88;;;;-1:-1:-1;;;74924:88:0;;27328:2:1;74924:88:0;;;27310:21:1;27367:2;27347:18;;;27340:30;27406:34;27386:18;;;27379:62;-1:-1:-1;;;27457:18:1;;;27450:40;27507:19;;74924:88:0;27126:406:1;74924:88:0;-1:-1:-1;;;;;75031:22:0;;75023:60;;;;-1:-1:-1;;;75023:60:0;;27739:2:1;75023:60:0;;;27721:21:1;27778:2;27758:18;;;27751:30;27817:27;27797:18;;;27790:55;27862:18;;75023:60:0;27537:349:1;75023:60:0;75118:35;;;;;;;;;-1:-1:-1;;;;;75118:35:0;;;;;;-1:-1:-1;;;;;75118:35:0;;;;;;;;;;-1:-1:-1;;;75096:57:0;;;;:19;:57;74829:332::o;94146:135::-;89429:4;89453:16;;;:7;:16;;;;;;-1:-1:-1;;;;;89453:16:0;94220:53;;;;-1:-1:-1;;;94220:53:0;;23306:2:1;94220:53:0;;;23288:21:1;23345:2;23325:18;;;23318:30;-1:-1:-1;;;23364:18:1;;;23357:54;23428:18;;94220:53:0;23104:348:1;85688:417:0;85769:13;85785:23;85800:7;85785:14;:23::i;:::-;85769:39;;85833:5;-1:-1:-1;;;;;85827:11:0;:2;-1:-1:-1;;;;;85827:11:0;;85819:57;;;;-1:-1:-1;;;85819:57:0;;28093:2:1;85819:57:0;;;28075:21:1;28132:2;28112:18;;;28105:30;28171:34;28151:18;;;28144:62;-1:-1:-1;;;28222:18:1;;;28215:31;28263:19;;85819:57:0;27891:397:1;85819:57:0;79490:10;-1:-1:-1;;;;;85911:21:0;;;;:62;;-1:-1:-1;85936:37:0;85953:5;79490:10;86640:164;:::i;85936:37::-;85889:174;;;;-1:-1:-1;;;85889:174:0;;28495:2:1;85889:174:0;;;28477:21:1;28534:2;28514:18;;;28507:30;28573:34;28553:18;;;28546:62;28644:32;28624:18;;;28617:60;28694:19;;85889:174:0;28293:426:1;85889:174:0;86076:21;86085:2;86089:7;86076:8;:21::i;122365:101::-;122436:22;122446:2;122450:7;122436:9;:22::i;35238:146::-;35315:4;28254:19;;;:12;;;:19;;;;;;:24;;35339:37;28157:129;88738:313;88894:28;88904:4;88910:2;88914:7;88894:9;:28::i;:::-;88941:47;88964:4;88970:2;88974:7;88983:4;88941:22;:47::i;:::-;88933:110;;;;-1:-1:-1;;;88933:110:0;;;;;;;:::i;125631:410::-;125737:15;125770:2;125755:11;125767:1;125755:14;;;;;;;;:::i;:::-;;;;;;;:17;;;;:::i;:::-;125783:16;125802:23;;;:12;:23;;;;;;;;;125838:22;;;:12;:22;;;;;;:32;;;125899:29;-1:-1:-1;;;125899:29:0;;;;;1951:25:1;;;125838:32:0;;-1:-1:-1;125802:23:0;125899:11;-1:-1:-1;;;;;125899:19:0;;;;1924:18:1;;125899:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;125941:88;;-1:-1:-1;;;125941:88:0;;125881:47;;-1:-1:-1;;;;;;125941:11:0;:28;;;;:88;;125881:47;;125987:4;;125994:8;;125941:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;125726:315;;;125631:410;;:::o;86871:336::-;87066:41;79490:10;87099:7;87066:18;:41::i;:::-;87058:100;;;;-1:-1:-1;;;87058:100:0;;;;;;;:::i;:::-;87171:28;87181:4;87187:2;87191:7;87171:9;:28::i;87278:185::-;87416:39;87433:4;87439:2;87443:7;87416:39;;;;;;;;;;;;:16;:39::i;82126:191::-;82219:6;;;-1:-1:-1;;;;;82236:17:0;;;-1:-1:-1;;;;;;82236:17:0;;;;;;;82269:40;;82219:6;;;82236:17;82219:6;;82269:40;;82200:16;;82269:40;82189:128;82126:191;:::o;86414:155::-;86509:52;79490:10;86542:8;86552;86509:18;:52::i;34708:131::-;34775:4;34799:32;34804:3;34824:5;34799:4;:32::i;87534:323::-;87708:41;79490:10;87741:7;87708:18;:41::i;:::-;87700:100;;;;-1:-1:-1;;;87700:100:0;;;;;;;:::i;:::-;87811:38;87825:4;87831:2;87835:7;87844:4;87811:13;:38::i;76664:723::-;76720:13;76941:5;76950:1;76941:10;76937:53;;-1:-1:-1;;76968:10:0;;;;;;;;;;;;-1:-1:-1;;;76968:10:0;;;;;76664:723::o;76937:53::-;77015:5;77000:12;77056:78;77063:9;;77056:78;;77089:8;;;;:::i;:::-;;-1:-1:-1;77112:10:0;;-1:-1:-1;77120:2:0;77112:10;;:::i;:::-;;;77056:78;;;77144:19;77176:6;-1:-1:-1;;;;;77166:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77166:17:0;;77144:39;;77194:154;77201:10;;77194:154;;77228:11;77238:1;77228:11;;:::i;:::-;;-1:-1:-1;77297:10:0;77305:2;77297:5;:10;:::i;:::-;77284:24;;:2;:24;:::i;:::-;77271:39;;77254:6;77261;77254:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;77254:56:0;;;;;;;;-1:-1:-1;77325:11:0;77334:2;77325:11;;:::i;:::-;;;77194:154;;;77372:6;76664:723;-1:-1:-1;;;;76664:723:0:o;97924:224::-;98026:4;-1:-1:-1;;;;;;98050:50:0;;-1:-1:-1;;;98050:50:0;;:90;;;98104:36;98128:11;98104:23;:36::i;29505:111::-;29561:16;29597:3;:11;;29590:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29505:111;;;:::o;93425:174::-;93500:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;93500:29:0;-1:-1:-1;;;;;93500:29:0;;;;;;;;:24;;93554:23;93500:24;93554:14;:23::i;:::-;-1:-1:-1;;;;;93545:46:0;;;;;;;;;;;93425:174;;:::o;90264:110::-;90340:26;90350:2;90354:7;90340:26;;;;;;;;;;;;:9;:26::i;92681:625::-;92840:4;-1:-1:-1;;;;;92813:31:0;:23;92828:7;92813:14;:23::i;:::-;-1:-1:-1;;;;;92813:31:0;;92805:81;;;;-1:-1:-1;;;92805:81:0;;29893:2:1;92805:81:0;;;29875:21:1;29932:2;29912:18;;;29905:30;29971:34;29951:18;;;29944:62;-1:-1:-1;;;30022:18:1;;;30015:35;30067:19;;92805:81:0;29691:401:1;92805:81:0;-1:-1:-1;;;;;92905:16:0;;92897:65;;;;-1:-1:-1;;;92897:65:0;;30299:2:1;92897:65:0;;;30281:21:1;30338:2;30318:18;;;30311:30;30377:34;30357:18;;;30350:62;-1:-1:-1;;;30428:18:1;;;30421:34;30472:19;;92897:65:0;30097:400:1;92897:65:0;92975:39;92996:4;93002:2;93006:7;92975:20;:39::i;:::-;93079:29;93096:1;93100:7;93079:8;:29::i;:::-;-1:-1:-1;;;;;93121:15:0;;;;;;:9;:15;;;;;:20;;93140:1;;93121:15;:20;;93140:1;;93121:20;:::i;:::-;;;;-1:-1:-1;;;;;;;93152:13:0;;;;;;:9;:13;;;;;:18;;93169:1;;93152:13;:18;;93169:1;;93152:18;:::i;:::-;;;;-1:-1:-1;;93181:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;93181:21:0;-1:-1:-1;;;;;93181:21:0;;;;;;;;;93220:27;;93181:16;;93220:27;;;;;;;129788:173;;;:::o;94845:853::-;94999:4;-1:-1:-1;;;;;95020:13:0;;49732:19;:23;95016:675;;95056:71;;-1:-1:-1;;;95056:71:0;;-1:-1:-1;;;;;95056:36:0;;;;;:71;;79490:10;;95107:4;;95113:7;;95122:4;;95056:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;95056:71:0;;;;;;;;-1:-1:-1;;95056:71:0;;;;;;;;;;;;:::i;:::-;;;95052:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95297:6;:13;95314:1;95297:18;95293:328;;95340:60;;-1:-1:-1;;;95340:60:0;;;;;;;:::i;95293:328::-;95571:6;95565:13;95556:6;95552:2;95548:15;95541:38;95052:584;-1:-1:-1;;;;;;95178:51:0;-1:-1:-1;;;95178:51:0;;-1:-1:-1;95171:58:0;;95016:675;-1:-1:-1;95675:4:0;94845:853;;;;;;:::o;89658:264::-;89751:4;89768:13;89784:23;89799:7;89784:14;:23::i;:::-;89768:39;;89837:5;-1:-1:-1;;;;;89826:16:0;:7;-1:-1:-1;;;;;89826:16:0;;:52;;;-1:-1:-1;;;;;;86761:25:0;;;86737:4;86761:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;89846:32;89826:87;;;;89906:7;-1:-1:-1;;;;;89882:31:0;:20;89894:7;89882:11;:20::i;:::-;-1:-1:-1;;;;;89882:31:0;;89818:96;89658:264;-1:-1:-1;;;;89658:264:0:o;93742:315::-;93897:8;-1:-1:-1;;;;;93888:17:0;:5;-1:-1:-1;;;;;93888:17:0;;93880:55;;;;-1:-1:-1;;;93880:55:0;;31452:2:1;93880:55:0;;;31434:21:1;31491:2;31471:18;;;31464:30;31530:27;31510:18;;;31503:55;31575:18;;93880:55:0;31250:349:1;93880:55:0;-1:-1:-1;;;;;93946:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;93946:46:0;;;;;;;;;;94008:41;;540::1;;;94008::0;;513:18:1;94008:41:0;;;;;;;93742:315;;;:::o;26061:414::-;26124:4;28254:19;;;:12;;;:19;;;;;;26141:327;;-1:-1:-1;26184:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;26367:18;;26345:19;;;:12;;;:19;;;;;;:40;;;;26400:11;;26141:327;-1:-1:-1;26451:5:0;26444:12;;83731:305;83833:4;-1:-1:-1;;;;;;83870:40:0;;-1:-1:-1;;;83870:40:0;;:105;;-1:-1:-1;;;;;;;83927:48:0;;-1:-1:-1;;;83927:48:0;83870:105;:158;;;-1:-1:-1;;;;;;;;;;72026:40:0;;;83992:36;71917:157;90601:319;90730:18;90736:2;90740:7;90730:5;:18::i;:::-;90781:53;90812:1;90816:2;90820:7;90829:4;90781:22;:53::i;:::-;90759:153;;;;-1:-1:-1;;;90759:153:0;;;;;;;:::i;99600:589::-;-1:-1:-1;;;;;99806:18:0;;99802:187;;99841:40;99873:7;101016:10;:17;;100989:24;;;;:15;:24;;;;;:44;;;101044:24;;;;;;;;;;;;100912:164;99841:40;99802:187;;;99911:2;-1:-1:-1;;;;;99903:10:0;:4;-1:-1:-1;;;;;99903:10:0;;99899:90;;99930:47;99963:4;99969:7;99930:32;:47::i;:::-;-1:-1:-1;;;;;100003:16:0;;99999:183;;100036:45;100073:7;100036:36;:45::i;99999:183::-;100109:4;-1:-1:-1;;;;;100103:10:0;:2;-1:-1:-1;;;;;100103:10:0;;100099:83;;100130:40;100158:2;100162:7;100130:27;:40::i;91256:439::-;-1:-1:-1;;;;;91336:16:0;;91328:61;;;;-1:-1:-1;;;91328:61:0;;31806:2:1;91328:61:0;;;31788:21:1;;;31825:18;;;31818:30;31884:34;31864:18;;;31857:62;31936:18;;91328:61:0;31604:356:1;91328:61:0;89429:4;89453:16;;;:7;:16;;;;;;-1:-1:-1;;;;;89453:16:0;:30;91400:58;;;;-1:-1:-1;;;91400:58:0;;32167:2:1;91400:58:0;;;32149:21:1;32206:2;32186:18;;;32179:30;32245;32225:18;;;32218:58;32293:18;;91400:58:0;31965:352:1;91400:58:0;91471:45;91500:1;91504:2;91508:7;91471:20;:45::i;:::-;-1:-1:-1;;;;;91529:13:0;;;;;;:9;:13;;;;;:18;;91546:1;;91529:13;:18;;91546:1;;91529:18;:::i;:::-;;;;-1:-1:-1;;91558:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;91558:21:0;-1:-1:-1;;;;;91558:21:0;;;;;;;;91597:33;;91558:16;;;91597:33;;91558:16;;91597:33;129110:158;;:::o;101703:988::-;101969:22;102019:1;101994:22;102011:4;101994:16;:22::i;:::-;:26;;;;:::i;:::-;102031:18;102052:26;;;:17;:26;;;;;;101969:51;;-1:-1:-1;102185:28:0;;;102181:328;;-1:-1:-1;;;;;102252:18:0;;102230:19;102252:18;;;:12;:18;;;;;;;;:34;;;;;;;;;102303:30;;;;;;:44;;;102420:30;;:17;:30;;;;;:43;;;102181:328;-1:-1:-1;102605:26:0;;;;:17;:26;;;;;;;;102598:33;;;-1:-1:-1;;;;;102649:18:0;;;;;:12;:18;;;;;:34;;;;;;;102642:41;101703:988::o;102986:1079::-;103264:10;:17;103239:22;;103264:21;;103284:1;;103264:21;:::i;:::-;103296:18;103317:24;;;:15;:24;;;;;;103690:10;:26;;103239:46;;-1:-1:-1;103317:24:0;;103239:46;;103690:26;;;;;;:::i;:::-;;;;;;;;;103668:48;;103754:11;103729:10;103740;103729:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;103834:28;;;:15;:28;;;;;;;:41;;;104006:24;;;;;103999:31;104041:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;103057:1008;;;102986:1079;:::o;100490:221::-;100575:14;100592:20;100609:2;100592:16;:20::i;:::-;-1:-1:-1;;;;;100623:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;100668:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;100490:221:0:o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:632::-;763:2;815:21;;;885:13;;788:18;;;907:22;;;734:4;;763:2;986:15;;;;960:2;945:18;;;734:4;1029:169;1043:6;1040:1;1037:13;1029:169;;;1104:13;;1092:26;;1173:15;;;;1138:12;;;;1065:1;1058:9;1029:169;;;-1:-1:-1;1215:3:1;;592:632;-1:-1:-1;;;;;;592:632:1:o;1229:131::-;-1:-1:-1;;;;;1304:31:1;;1294:42;;1284:70;;1350:1;1347;1340:12;1365:435;1432:6;1440;1493:2;1481:9;1472:7;1468:23;1464:32;1461:52;;;1509:1;1506;1499:12;1461:52;1548:9;1535:23;1567:31;1592:5;1567:31;:::i;:::-;1617:5;-1:-1:-1;1674:2:1;1659:18;;1646:32;-1:-1:-1;;;;;1709:40:1;;1697:53;;1687:81;;1764:1;1761;1754:12;1687:81;1787:7;1777:17;;;1365:435;;;;;:::o;1987:250::-;2072:1;2082:113;2096:6;2093:1;2090:13;2082:113;;;2172:11;;;2166:18;2153:11;;;2146:39;2118:2;2111:10;2082:113;;;-1:-1:-1;;2229:1:1;2211:16;;2204:27;1987:250::o;2242:271::-;2284:3;2322:5;2316:12;2349:6;2344:3;2337:19;2365:76;2434:6;2427:4;2422:3;2418:14;2411:4;2404:5;2400:16;2365:76;:::i;:::-;2495:2;2474:15;-1:-1:-1;;2470:29:1;2461:39;;;;2502:4;2457:50;;2242:271;-1:-1:-1;;2242:271:1:o;2518:220::-;2667:2;2656:9;2649:21;2630:4;2687:45;2728:2;2717:9;2713:18;2705:6;2687:45;:::i;2743:180::-;2802:6;2855:2;2843:9;2834:7;2830:23;2826:32;2823:52;;;2871:1;2868;2861:12;2823:52;-1:-1:-1;2894:23:1;;2743:180;-1:-1:-1;2743:180:1:o;3136:315::-;3204:6;3212;3265:2;3253:9;3244:7;3240:23;3236:32;3233:52;;;3281:1;3278;3271:12;3233:52;3320:9;3307:23;3339:31;3364:5;3339:31;:::i;:::-;3389:5;3441:2;3426:18;;;;3413:32;;-1:-1:-1;;;3136:315:1:o;3456:127::-;3517:10;3512:3;3508:20;3505:1;3498:31;3548:4;3545:1;3538:15;3572:4;3569:1;3562:15;3588:275;3659:2;3653:9;3724:2;3705:13;;-1:-1:-1;;3701:27:1;3689:40;;-1:-1:-1;;;;;3744:34:1;;3780:22;;;3741:62;3738:88;;;3806:18;;:::i;:::-;3842:2;3835:22;3588:275;;-1:-1:-1;3588:275:1:o;3868:406::-;3932:5;-1:-1:-1;;;;;3958:6:1;3955:30;3952:56;;;3988:18;;:::i;:::-;4026:57;4071:2;4050:15;;-1:-1:-1;;4046:29:1;4077:4;4042:40;4026:57;:::i;:::-;4017:66;;4106:6;4099:5;4092:21;4146:3;4137:6;4132:3;4128:16;4125:25;4122:45;;;4163:1;4160;4153:12;4122:45;4212:6;4207:3;4200:4;4193:5;4189:16;4176:43;4266:1;4259:4;4250:6;4243:5;4239:18;4235:29;4228:40;3868:406;;;;;:::o;4279:794::-;4374:6;4382;4390;4398;4451:3;4439:9;4430:7;4426:23;4422:33;4419:53;;;4468:1;4465;4458:12;4419:53;4507:9;4494:23;4526:31;4551:5;4526:31;:::i;:::-;4576:5;-1:-1:-1;4633:2:1;4618:18;;4605:32;4646:33;4605:32;4646:33;:::i;:::-;4698:7;-1:-1:-1;4752:2:1;4737:18;;4724:32;;-1:-1:-1;4807:2:1;4792:18;;4779:32;-1:-1:-1;;;;;4823:30:1;;4820:50;;;4866:1;4863;4856:12;4820:50;4889:22;;4942:4;4934:13;;4930:27;-1:-1:-1;4920:55:1;;4971:1;4968;4961:12;4920:55;4994:73;5059:7;5054:2;5041:16;5036:2;5032;5028:11;4994:73;:::i;:::-;4984:83;;;4279:794;;;;;;;:::o;5285:712::-;5339:5;5392:3;5385:4;5377:6;5373:17;5369:27;5359:55;;5410:1;5407;5400:12;5359:55;5446:6;5433:20;5472:4;-1:-1:-1;;;;;5491:2:1;5488:26;5485:52;;;5517:18;;:::i;:::-;5563:2;5560:1;5556:10;5586:28;5610:2;5606;5602:11;5586:28;:::i;:::-;5648:15;;;5718;;;5714:24;;;5679:12;;;;5750:15;;;5747:35;;;5778:1;5775;5768:12;5747:35;5814:2;5806:6;5802:15;5791:26;;5826:142;5842:6;5837:3;5834:15;5826:142;;;5908:17;;5896:30;;5859:12;;;;5946;;;;5826:142;;;5986:5;5285:712;-1:-1:-1;;;;;;;5285:712:1:o;6002:416::-;6095:6;6103;6156:2;6144:9;6135:7;6131:23;6127:32;6124:52;;;6172:1;6169;6162:12;6124:52;6208:9;6195:23;6185:33;;6269:2;6258:9;6254:18;6241:32;-1:-1:-1;;;;;6288:6:1;6285:30;6282:50;;;6328:1;6325;6318:12;6282:50;6351:61;6404:7;6395:6;6384:9;6380:22;6351:61;:::i;:::-;6341:71;;;6002:416;;;;;:::o;6423:456::-;6500:6;6508;6516;6569:2;6557:9;6548:7;6544:23;6540:32;6537:52;;;6585:1;6582;6575:12;6537:52;6624:9;6611:23;6643:31;6668:5;6643:31;:::i;:::-;6693:5;-1:-1:-1;6750:2:1;6735:18;;6722:32;6763:33;6722:32;6763:33;:::i;:::-;6423:456;;6815:7;;-1:-1:-1;;;6869:2:1;6854:18;;;;6841:32;;6423:456::o;6884:248::-;6952:6;6960;7013:2;7001:9;6992:7;6988:23;6984:32;6981:52;;;7029:1;7026;7019:12;6981:52;-1:-1:-1;;7052:23:1;;;7122:2;7107:18;;;7094:32;;-1:-1:-1;6884:248:1:o;7416:171::-;7483:20;;-1:-1:-1;;;;;7532:30:1;;7522:41;;7512:69;;7577:1;7574;7567:12;7592:184;7650:6;7703:2;7691:9;7682:7;7678:23;7674:32;7671:52;;;7719:1;7716;7709:12;7671:52;7742:28;7760:9;7742:28;:::i;8465:118::-;8551:5;8544:13;8537:21;8530:5;8527:32;8517:60;;8573:1;8570;8563:12;8588:377;8662:6;8670;8678;8731:2;8719:9;8710:7;8706:23;8702:32;8699:52;;;8747:1;8744;8737:12;8699:52;8783:9;8770:23;8760:33;;8843:2;8832:9;8828:18;8815:32;8856:28;8878:5;8856:28;:::i;8970:221::-;9013:5;9066:3;9059:4;9051:6;9047:17;9043:27;9033:55;;9084:1;9081;9074:12;9033:55;9106:79;9181:3;9172:6;9159:20;9152:4;9144:6;9140:17;9106:79;:::i;9196:322::-;9265:6;9318:2;9306:9;9297:7;9293:23;9289:32;9286:52;;;9334:1;9331;9324:12;9286:52;9374:9;9361:23;-1:-1:-1;;;;;9399:6:1;9396:30;9393:50;;;9439:1;9436;9429:12;9393:50;9462;9504:7;9495:6;9484:9;9480:22;9462:50;:::i;9523:247::-;9582:6;9635:2;9623:9;9614:7;9610:23;9606:32;9603:52;;;9651:1;9648;9641:12;9603:52;9690:9;9677:23;9709:31;9734:5;9709:31;:::i;9775:163::-;9842:20;;9902:10;9891:22;;9881:33;;9871:61;;9928:1;9925;9918:12;9943:159;10010:20;;10070:6;10059:18;;10049:29;;10039:57;;10092:1;10089;10082:12;10107:397;10190:6;10198;10206;10214;10267:3;10255:9;10246:7;10242:23;10238:33;10235:53;;;10284:1;10281;10274:12;10235:53;10307:28;10325:9;10307:28;:::i;:::-;10297:38;;10382:2;10371:9;10367:18;10354:32;10344:42;;10405:37;10438:2;10427:9;10423:18;10405:37;:::i;:::-;10395:47;;10461:37;10494:2;10483:9;10479:18;10461:37;:::i;:::-;10451:47;;10107:397;;;;;;;:::o;10509:184::-;10567:6;10620:2;10608:9;10599:7;10595:23;10591:32;10588:52;;;10636:1;10633;10626:12;10588:52;10659:28;10677:9;10659:28;:::i;10883:382::-;10948:6;10956;11009:2;10997:9;10988:7;10984:23;10980:32;10977:52;;;11025:1;11022;11015:12;10977:52;11064:9;11051:23;11083:31;11108:5;11083:31;:::i;:::-;11133:5;-1:-1:-1;11190:2:1;11175:18;;11162:32;11203:30;11162:32;11203:30;:::i;11270:184::-;11328:6;11381:2;11369:9;11360:7;11356:23;11352:32;11349:52;;;11397:1;11394;11387:12;11349:52;11420:28;11438:9;11420:28;:::i;11459:348::-;11543:6;11596:2;11584:9;11575:7;11571:23;11567:32;11564:52;;;11612:1;11609;11602:12;11564:52;11652:9;11639:23;-1:-1:-1;;;;;11677:6:1;11674:30;11671:50;;;11717:1;11714;11707:12;11671:50;11740:61;11793:7;11784:6;11773:9;11769:22;11740:61;:::i;11812:241::-;11868:6;11921:2;11909:9;11900:7;11896:23;11892:32;11889:52;;;11937:1;11934;11927:12;11889:52;11976:9;11963:23;11995:28;12017:5;11995:28;:::i;12058:390::-;12136:6;12144;12197:2;12185:9;12176:7;12172:23;12168:32;12165:52;;;12213:1;12210;12203:12;12165:52;12253:9;12240:23;-1:-1:-1;;;;;12278:6:1;12275:30;12272:50;;;12318:1;12315;12308:12;12272:50;12341;12383:7;12374:6;12363:9;12359:22;12341:50;:::i;:::-;12331:60;12438:2;12423:18;;;;12410:32;;-1:-1:-1;;;;12058:390:1:o;12453:388::-;12521:6;12529;12582:2;12570:9;12561:7;12557:23;12553:32;12550:52;;;12598:1;12595;12588:12;12550:52;12637:9;12624:23;12656:31;12681:5;12656:31;:::i;:::-;12706:5;-1:-1:-1;12763:2:1;12748:18;;12735:32;12776:33;12735:32;12776:33;:::i;12846:380::-;12925:1;12921:12;;;;12968;;;12989:61;;13043:4;13035:6;13031:17;13021:27;;12989:61;13096:2;13088:6;13085:14;13065:18;13062:38;13059:161;;13142:10;13137:3;13133:20;13130:1;13123:31;13177:4;13174:1;13167:15;13205:4;13202:1;13195:15;13059:161;;12846:380;;;:::o;13540:245::-;13607:6;13660:2;13648:9;13639:7;13635:23;13631:32;13628:52;;;13676:1;13673;13666:12;13628:52;13708:9;13702:16;13727:28;13749:5;13727:28;:::i;14150:348::-;14352:2;14334:21;;;14391:2;14371:18;;;14364:30;14430:26;14425:2;14410:18;;14403:54;14489:2;14474:18;;14150:348::o;14869:127::-;14930:10;14925:3;14921:20;14918:1;14911:31;14961:4;14958:1;14951:15;14985:4;14982:1;14975:15;15001:127;15062:10;15057:3;15053:20;15050:1;15043:31;15093:4;15090:1;15083:15;15117:4;15114:1;15107:15;15133:125;15198:9;;;15219:10;;;15216:36;;;15232:18;;:::i;16057:168::-;16130:9;;;16161;;16178:15;;;16172:22;;16158:37;16148:71;;16199:18;;:::i;16230:127::-;16291:10;16286:3;16282:20;16279:1;16272:31;16322:4;16319:1;16312:15;16346:4;16343:1;16336:15;16362:120;16402:1;16428;16418:35;;16433:18;;:::i;:::-;-1:-1:-1;16467:9:1;;16362:120::o;17671:184::-;17741:6;17794:2;17782:9;17773:7;17769:23;17765:32;17762:52;;;17810:1;17807;17800:12;17762:52;-1:-1:-1;17833:16:1;;17671:184;-1:-1:-1;17671:184:1:o;18218:251::-;18288:6;18341:2;18329:9;18320:7;18316:23;18312:32;18309:52;;;18357:1;18354;18347:12;18309:52;18389:9;18383:16;18408:31;18433:5;18408:31;:::i;20277:618::-;-1:-1:-1;;;;;20600:15:1;;;20582:34;;20652:15;;;;20647:2;20632:18;;20625:43;20699:2;20684:18;;20677:34;;;;20747:3;20742:2;20727:18;;20720:31;;;20788:2;20767:19;;;20760:31;-1:-1:-1;;;20562:3:1;20807:19;;20800:53;20885:3;20870:19;;20277:618::o;21026:545::-;21128:2;21123:3;21120:11;21117:448;;;21164:1;21189:5;21185:2;21178:17;21234:4;21230:2;21220:19;21304:2;21292:10;21288:19;21285:1;21281:27;21275:4;21271:38;21340:4;21328:10;21325:20;21322:47;;;-1:-1:-1;21363:4:1;21322:47;21418:2;21413:3;21409:12;21406:1;21402:20;21396:4;21392:31;21382:41;;21473:82;21491:2;21484:5;21481:13;21473:82;;;21536:17;;;21517:1;21506:13;21473:82;;;21477:3;;;21026:545;;;:::o;21747:1352::-;21873:3;21867:10;-1:-1:-1;;;;;21892:6:1;21889:30;21886:56;;;21922:18;;:::i;:::-;21951:97;22041:6;22001:38;22033:4;22027:11;22001:38;:::i;:::-;21995:4;21951:97;:::i;:::-;22103:4;;22167:2;22156:14;;22184:1;22179:663;;;;22886:1;22903:6;22900:89;;;-1:-1:-1;22955:19:1;;;22949:26;22900:89;-1:-1:-1;;21704:1:1;21700:11;;;21696:24;21692:29;21682:40;21728:1;21724:11;;;21679:57;23002:81;;22149:944;;22179:663;20973:1;20966:14;;;21010:4;20997:18;;-1:-1:-1;;22215:20:1;;;22333:236;22347:7;22344:1;22341:14;22333:236;;;22436:19;;;22430:26;22415:42;;22528:27;;;;22496:1;22484:14;;;;22363:19;;22333:236;;;22337:3;22597:6;22588:7;22585:19;22582:201;;;22658:19;;;22652:26;-1:-1:-1;;22741:1:1;22737:14;;;22753:3;22733:24;22729:37;22725:42;22710:58;22695:74;;22582:201;-1:-1:-1;;;;;22829:1:1;22813:14;;;22809:22;22796:36;;-1:-1:-1;21747:1352:1:o;23867:135::-;23906:3;23927:17;;;23924:43;;23947:18;;:::i;:::-;-1:-1:-1;23994:1:1;23983:13;;23867:135::o;24357:112::-;24389:1;24415;24405:35;;24420:18;;:::i;:::-;-1:-1:-1;24454:9:1;;24357:112::o;24474:1020::-;24650:3;24679:1;24712:6;24706:13;24742:36;24768:9;24742:36;:::i;:::-;24797:1;24814:18;;;24841:133;;;;24988:1;24983:356;;;;24807:532;;24841:133;-1:-1:-1;;24874:24:1;;24862:37;;24947:14;;24940:22;24928:35;;24919:45;;;-1:-1:-1;24841:133:1;;24983:356;25014:6;25011:1;25004:17;25044:4;25089:2;25086:1;25076:16;25114:1;25128:165;25142:6;25139:1;25136:13;25128:165;;;25220:14;;25207:11;;;25200:35;25263:16;;;;25157:10;;25128:165;;;25132:3;;;25322:6;25317:3;25313:16;25306:23;;24807:532;;;;;25370:6;25364:13;25386:68;25445:8;25440:3;25433:4;25425:6;25421:17;25386:68;:::i;:::-;25470:18;;24474:1020;-1:-1:-1;;;;24474:1020:1:o;25499:496::-;25678:3;25716:6;25710:13;25732:66;25791:6;25786:3;25779:4;25771:6;25767:17;25732:66;:::i;:::-;25861:13;;25820:16;;;;25883:70;25861:13;25820:16;25930:4;25918:17;;25883:70;:::i;28724:414::-;28926:2;28908:21;;;28965:2;28945:18;;;28938:30;29004:34;28999:2;28984:18;;28977:62;-1:-1:-1;;;29070:2:1;29055:18;;29048:48;29128:3;29113:19;;28724:414::o;29143:410::-;29345:2;29327:21;;;29384:2;29364:18;;;29357:30;29423:34;29418:2;29403:18;;29396:62;-1:-1:-1;;;29489:2:1;29474:18;;29467:44;29543:3;29528:19;;29143:410::o;29558:128::-;29625:9;;;29646:11;;;29643:37;;;29660:18;;:::i;30502:489::-;-1:-1:-1;;;;;30771:15:1;;;30753:34;;30823:15;;30818:2;30803:18;;30796:43;30870:2;30855:18;;30848:34;;;30918:3;30913:2;30898:18;;30891:31;;;30696:4;;30939:46;;30965:19;;30957:6;30939:46;:::i;:::-;30931:54;30502:489;-1:-1:-1;;;;;;30502:489:1:o;30996:249::-;31065:6;31118:2;31106:9;31097:7;31093:23;31089:32;31086:52;;;31134:1;31131;31124:12;31086:52;31166:9;31160:16;31185:30;31209:5;31185:30;:::i;32322:127::-;32383:10;32378:3;32374:20;32371:1;32364:31;32414:4;32411:1;32404:15;32438:4;32435:1;32428:15
Swarm Source
ipfs://2e33978f90b9c0753973e42be17129f2a90318886dbca7928adae53d2974c45d
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.