More Info
Private Name Tags
ContractCreator:
TokenTracker
Latest 25 from a total of 3,904 transactions
Transaction Hash |
Method
|
Block
|
From
|
To
|
Value | ||||
---|---|---|---|---|---|---|---|---|---|
Set Approval For... | 52445354 | 70 days ago | IN | 0 MATIC | 0.00104932 | ||||
Approve | 44323420 | 277 days ago | IN | 0 MATIC | 0.00567438 | ||||
Approve | 44323324 | 277 days ago | IN | 0 MATIC | 0.00591482 | ||||
Approve | 44323263 | 277 days ago | IN | 0 MATIC | 0.00586673 | ||||
Approve | 44323154 | 277 days ago | IN | 0 MATIC | 0.0055782 | ||||
Approve | 44323034 | 277 days ago | IN | 0 MATIC | 0.00364081 | ||||
Approve | 44322987 | 277 days ago | IN | 0 MATIC | 0.00575853 | ||||
Approve | 44322768 | 277 days ago | IN | 0 MATIC | 0.00600454 | ||||
Approve | 44322453 | 277 days ago | IN | 0 MATIC | 0.00407771 | ||||
Safe Transfer Fr... | 42178790 | 332 days ago | IN | 0 MATIC | 0.02943564 | ||||
Safe Transfer Fr... | 42178790 | 332 days ago | IN | 0 MATIC | 0.02943564 | ||||
Safe Transfer Fr... | 42178790 | 332 days ago | IN | 0 MATIC | 0.02943564 | ||||
Safe Transfer Fr... | 42178790 | 332 days ago | IN | 0 MATIC | 0.02943564 | ||||
Safe Transfer Fr... | 42178790 | 332 days ago | IN | 0 MATIC | 0.02943564 | ||||
Safe Transfer Fr... | 42178790 | 332 days ago | IN | 0 MATIC | 0.02943564 | ||||
Safe Transfer Fr... | 42178787 | 332 days ago | IN | 0 MATIC | 0.02943564 | ||||
Safe Transfer Fr... | 42178786 | 332 days ago | IN | 0 MATIC | 0.08792831 | ||||
Set Approval For... | 41341024 | 353 days ago | IN | 0 MATIC | 0.00324756 | ||||
Set Approval For... | 41341024 | 353 days ago | IN | 0 MATIC | 0.00332677 | ||||
Set Approval For... | 41341024 | 353 days ago | IN | 0 MATIC | 0.00307477 | ||||
Safe Transfer Fr... | 40754386 | 369 days ago | IN | 0 MATIC | 0.02763566 | ||||
Safe Transfer Fr... | 40754386 | 369 days ago | IN | 0 MATIC | 0.02763566 | ||||
Safe Transfer Fr... | 40754386 | 369 days ago | IN | 0 MATIC | 0.02763566 | ||||
Safe Transfer Fr... | 40754386 | 369 days ago | IN | 0 MATIC | 0.02763566 | ||||
Safe Transfer Fr... | 40754385 | 369 days ago | IN | 0 MATIC | 0.02763566 |
Loading...
Loading
Contract Name:
OYABUN
Compiler Version
v0.8.7+commit.e28d00a7
Contract Source Code (Solidity)
/** *Submitted for verification at polygonscan.com on 2022-08-15 */ // SPDX-License-Identifier: MIT // 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/token/ERC20/extensions/draft-IERC20Permit.sol // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612]. * * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't * need to send a transaction, and thus is not required to hold Ether at all. */ interface IERC20Permit { /** * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens, * given ``owner``'s signed approval. * * IMPORTANT: The same issues {IERC20-approve} has related to transaction * ordering also apply here. * * Emits an {Approval} event. * * Requirements: * * - `spender` cannot be the zero address. * - `deadline` must be a timestamp in the future. * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner` * over the EIP712-formatted function arguments. * - the signature must use ``owner``'s current nonce (see {nonces}). * * For more information on the signature format, see the * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP * section]. */ function permit( address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) external; /** * @dev Returns the current nonce for `owner`. This value must be * included whenever a signature is generated for {permit}. * * Every successful call to {permit} increases ``owner``'s nonce by one. This * prevents a signature from being used multiple times. */ function nonces(address owner) external view returns (uint256); /** * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}. */ // solhint-disable-next-line func-name-mixedcase function DOMAIN_SEPARATOR() external view returns (bytes32); } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); } // 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/cryptography/MerkleProof.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/cryptography/MerkleProof.sol) pragma solidity ^0.8.0; /** * @dev These functions deal with verification of Merkle Tree proofs. * * The proofs can be generated using the JavaScript library * https://github.com/miguelmota/merkletreejs[merkletreejs]. * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled. * * See `test/utils/cryptography/MerkleProof.test.js` for some examples. * * WARNING: You should avoid using leaf values that are 64 bytes long prior to * hashing, or use a hash function other than keccak256 for hashing leaves. * This is because the concatenation of a sorted pair of internal nodes in * the merkle tree could be reinterpreted as a leaf value. */ library MerkleProof { /** * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree * defined by `root`. For this, a `proof` must be provided, containing * sibling hashes on the branch from the leaf to the root of the tree. Each * pair of leaves and each pair of pre-images are assumed to be sorted. */ function verify( bytes32[] memory proof, bytes32 root, bytes32 leaf ) internal pure returns (bool) { return processProof(proof, leaf) == root; } /** * @dev Calldata version of {verify} * * _Available since v4.7._ */ function verifyCalldata( bytes32[] calldata proof, bytes32 root, bytes32 leaf ) internal pure returns (bool) { return processProofCalldata(proof, leaf) == root; } /** * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt * hash matches the root of the tree. When processing the proof, the pairs * of leafs & pre-images are assumed to be sorted. * * _Available since v4.4._ */ function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Calldata version of {processProof} * * _Available since v4.7._ */ function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) { bytes32 computedHash = leaf; for (uint256 i = 0; i < proof.length; i++) { computedHash = _hashPair(computedHash, proof[i]); } return computedHash; } /** * @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}. * * _Available since v4.7._ */ function multiProofVerify( bytes32[] memory proof, bool[] memory proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProof(proof, proofFlags, leaves) == root; } /** * @dev Calldata version of {multiProofVerify} * * _Available since v4.7._ */ function multiProofVerifyCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32 root, bytes32[] memory leaves ) internal pure returns (bool) { return processMultiProofCalldata(proof, proofFlags, leaves) == root; } /** * @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`, * consuming from one or the other at each step according to the instructions given by * `proofFlags`. * * _Available since v4.7._ */ function processMultiProof( bytes32[] memory proof, bool[] memory proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } /** * @dev Calldata version of {processMultiProof} * * _Available since v4.7._ */ function processMultiProofCalldata( bytes32[] calldata proof, bool[] calldata proofFlags, bytes32[] memory leaves ) internal pure returns (bytes32 merkleRoot) { // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of // the merkle tree. uint256 leavesLen = leaves.length; uint256 totalHashes = proofFlags.length; // Check proof validity. require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof"); // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop". bytes32[] memory hashes = new bytes32[](totalHashes); uint256 leafPos = 0; uint256 hashPos = 0; uint256 proofPos = 0; // At each step, we compute the next hash using two values: // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we // get the next hash. // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the // `proof` array. for (uint256 i = 0; i < totalHashes; i++) { bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++]; bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++]; hashes[i] = _hashPair(a, b); } if (totalHashes > 0) { return hashes[totalHashes - 1]; } else if (leavesLen > 0) { return leaves[0]; } else { return proof[0]; } } function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) { return a < b ? _efficientHash(a, b) : _efficientHash(b, a); } function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) { /// @solidity memory-safe-assembly assembly { mstore(0x00, a) mstore(0x20, b) value := keccak256(0x00, 0x40) } } } // 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/security/Pausable.sol // OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor() { _paused = false; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { _requireNotPaused(); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { _requirePaused(); _; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Throws if the contract is paused. */ function _requireNotPaused() internal view virtual { require(!paused(), "Pausable: paused"); } /** * @dev Throws if the contract is not paused. */ function _requirePaused() internal view virtual { require(paused(), "Pausable: not paused"); } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.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/ERC20/utils/SafeERC20.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol) pragma solidity ^0.8.0; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using Address for address; function safeTransfer( IERC20 token, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom( IERC20 token, address from, address to, uint256 value ) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove( IERC20 token, address spender, uint256 value ) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' require( (value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance( IERC20 token, address spender, uint256 value ) internal { uint256 newAllowance = token.allowance(address(this), spender) + value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance( IERC20 token, address spender, uint256 value ) internal { unchecked { uint256 oldAllowance = token.allowance(address(this), spender); require(oldAllowance >= value, "SafeERC20: decreased allowance below zero"); uint256 newAllowance = oldAllowance - value; _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } } function safePermit( IERC20Permit token, address owner, address spender, uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s ) internal { uint256 nonceBefore = token.nonces(owner); token.permit(owner, spender, value, deadline, v, r, s); uint256 nonceAfter = token.nonces(owner); require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed"); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } } // File: @openzeppelin/contracts/finance/PaymentSplitter.sol // OpenZeppelin Contracts (last updated v4.7.0) (finance/PaymentSplitter.sol) pragma solidity ^0.8.0; /** * @title PaymentSplitter * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware * that the Ether will be split in this way, since it is handled transparently by the contract. * * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim * an amount proportional to the percentage of total shares they were assigned. The distribution of shares is set at the * time of contract deployment and can't be updated thereafter. * * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release} * function. * * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you * to run tests before sending real value to this contract. */ contract PaymentSplitter is Context { event PayeeAdded(address account, uint256 shares); event PaymentReleased(address to, uint256 amount); event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount); event PaymentReceived(address from, uint256 amount); uint256 private _totalShares; uint256 private _totalReleased; mapping(address => uint256) private _shares; mapping(address => uint256) private _released; address[] private _payees; mapping(IERC20 => uint256) private _erc20TotalReleased; mapping(IERC20 => mapping(address => uint256)) private _erc20Released; /** * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at * the matching position in the `shares` array. * * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no * duplicates in `payees`. */ constructor(address[] memory payees, uint256[] memory shares_) payable { require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch"); require(payees.length > 0, "PaymentSplitter: no payees"); for (uint256 i = 0; i < payees.length; i++) { _addPayee(payees[i], shares_[i]); } } /** * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the * reliability of the events, and not the actual splitting of Ether. * * To learn more about this see the Solidity documentation for * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback * functions]. */ receive() external payable virtual { emit PaymentReceived(_msgSender(), msg.value); } /** * @dev Getter for the total shares held by payees. */ function totalShares() public view returns (uint256) { return _totalShares; } /** * @dev Getter for the total amount of Ether already released. */ function totalReleased() public view returns (uint256) { return _totalReleased; } /** * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20 * contract. */ function totalReleased(IERC20 token) public view returns (uint256) { return _erc20TotalReleased[token]; } /** * @dev Getter for the amount of shares held by an account. */ function shares(address account) public view returns (uint256) { return _shares[account]; } /** * @dev Getter for the amount of Ether already released to a payee. */ function released(address account) public view returns (uint256) { return _released[account]; } /** * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an * IERC20 contract. */ function released(IERC20 token, address account) public view returns (uint256) { return _erc20Released[token][account]; } /** * @dev Getter for the address of the payee number `index`. */ function payee(uint256 index) public view returns (address) { return _payees[index]; } /** * @dev Getter for the amount of payee's releasable Ether. */ function releasable(address account) public view returns (uint256) { uint256 totalReceived = address(this).balance + totalReleased(); return _pendingPayment(account, totalReceived, released(account)); } /** * @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an * IERC20 contract. */ function releasable(IERC20 token, address account) public view returns (uint256) { uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token); return _pendingPayment(account, totalReceived, released(token, account)); } /** * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the * total shares and their previous withdrawals. */ function release(address payable account) public virtual { require(_shares[account] > 0, "PaymentSplitter: account has no shares"); uint256 payment = releasable(account); require(payment != 0, "PaymentSplitter: account is not due payment"); _released[account] += payment; _totalReleased += payment; Address.sendValue(account, payment); emit PaymentReleased(account, payment); } /** * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20 * contract. */ function release(IERC20 token, address account) public virtual { require(_shares[account] > 0, "PaymentSplitter: account has no shares"); uint256 payment = releasable(token, account); require(payment != 0, "PaymentSplitter: account is not due payment"); _erc20Released[token][account] += payment; _erc20TotalReleased[token] += payment; SafeERC20.safeTransfer(token, account, payment); emit ERC20PaymentReleased(token, account, payment); } /** * @dev internal logic for computing the pending payment of an `account` given the token historical balances and * already released amounts. */ function _pendingPayment( address account, uint256 totalReceived, uint256 alreadyReleased ) private view returns (uint256) { return (totalReceived * _shares[account]) / _totalShares - alreadyReleased; } /** * @dev Add a new payee to the contract. * @param account The address of the payee to add. * @param shares_ The number of shares owned by the payee. */ function _addPayee(address account, uint256 shares_) private { require(account != address(0), "PaymentSplitter: account is the zero address"); require(shares_ > 0, "PaymentSplitter: shares are 0"); require(_shares[account] == 0, "PaymentSplitter: account already has shares"); _payees.push(account); _shares[account] = shares_; _totalShares = _totalShares + shares_; emit PayeeAdded(account, shares_); } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol // OpenZeppelin Contracts (last updated v4.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/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: NFT.sol pragma solidity ^0.8.7; /// @title Contract of your NFTs collection contract OYABUN is ERC721Enumerable, PaymentSplitter, Ownable, ReentrancyGuard, Pausable { //To increment the id of the NFTs using Counters for Counters.Counter; //To concatenate the URL of an NFipfs://sssssT using Strings for uint256; address[] public whitelisted = [0xcEB541F0F656Ec5180E3c24980F51aBA00a5d43C]; //Id of the next NFT to mint Counters.Counter private _nftIdCounter; //Number of NFTs in the collection uint public constant MAX_SUPPLY = 2084; //Maximum number of NFTs an address can mint uint public max_mint_allowed = 3; //Price of one NFT in presale uint public pricePresale = 1 gwei; //Price of one NFT in sale // uint public priceSale = 0.0003 ether; // Set the price of nft in depending on the number you want to buy mapping(uint => uint) public priceSale; //URI of the NFTs when revealed string private _baseURIVariable; //URI of the NFTs when not revealed string public notRevealedURI; //The extension of the file containing the Metadatas of the NFTs string public baseExtension = ".json"; //Are the NFTs revealed yet ? bool public revealed = false; //The different stages of selling the collection enum Steps { Before, Presale, Sale, SoldOut, Reveal } Steps public sellingStep; //Owner of the smart contract address private _owner; bool cancelWhitelist = false; //Keep a track of the number of tokens per address mapping(address => uint) nftsPerWallet; //Addresses of all the members of the team address[] private _team = [0x563cB1729C1B06E07567482702a3EB2E9cc5fe86]; //Shares of all the members of the team uint[] private _teamShares = [100]; // Address of the royalties recipient address private _royaltiesReceiver; // Percentage of each sale to pay as royalties uint256 public constant royaltiesPercentage = 5; // Represent a stake struct Stake { uint256 createdAt; address owner; bool instanciated; } bool private _stakingActivated = false; /** * @notice The staked NFT's and their stake information */ mapping(uint256 => Stake) public stakes; //Constructor of the collection constructor( string memory _theBaseURI, string memory _notRevealedURI, address _initialRoyaltiesReceiver ) ERC721("OyabunGenesis", "OYA") PaymentSplitter(_team, _teamShares) { transferOwnership(msg.sender); sellingStep = Steps.Before; _baseURIVariable = _theBaseURI; notRevealedURI = _notRevealedURI; _royaltiesReceiver = _initialRoyaltiesReceiver; _nftIdCounter.increment(); // Init the price of the nft in sale priceSale[1] = 297 ether; priceSale[2] = 247.5 ether; priceSale[3] = 198 ether; // // Gift 50 NFT to an address // address accountGifted = 0xd5552D43Fb973B12f03a8289D4b713e87Ec8a018; // for (uint256 i = 0; i < 50; i++) { // uint supply = totalSupply(); // require(supply + 1 <= MAX_SUPPLY, "Sold out"); // _safeMint(accountGifted, supply + 1); // } } /** * @notice Pause the contract * **/ function setPaused() external onlyOwner { _pause(); } /** * @notice Unpause the contract * **/ function unPaused() external onlyOwner { _unpause(); } modifier whenStakingNotPaused() { require(_stakingActivated, "Staking not started"); _; } function setStakingStatus(bool _status) public onlyOwner{ _stakingActivated = _status; } function stakeNFT(uint256 _tokenId) public whenNotPaused whenStakingNotPaused { _stakeNFT(_tokenId); } /** * @notice Use to stake a NFT * @param _tokenId the identifier of the NFT you want to stake */ function _stakeNFT(uint256 _tokenId) internal { // Verify that the token is owned by the caller require(_isApprovedOrOwner(msg.sender, _tokenId)); // Burn the token _burn(_tokenId); // Add the token to the stakes mapping stakes[_tokenId] = Stake( block.timestamp, msg.sender, true ); } function unstakeNFT(uint256 _tokenId) public whenNotPaused whenStakingNotPaused { _unstakeNFT(_tokenId); } /** * @notice Use to unstake a NFT * @param _tokenId the identifier of the NFT you want to unstake */ function _unstakeNFT(uint256 _tokenId) internal { // Verify that the stake exists require(stakes[_tokenId].instanciated, "The stake does not exist"); // Verify that the token is owned by the caller require( stakes[_tokenId].owner == msg.sender, "You are not the owner of the stake" ); // Remove the token from the stakes mapping Stake memory stake = stakes[_tokenId]; delete stakes[_tokenId]; // Add the token to the owner's balance _safeMint(stake.owner, _tokenId); } function unstakeAll() onlyOwner external { for(uint256 i = 0; i < _nftIdCounter.current(); i++) { if (stakes[i].instanciated) { // Remove the token from the stakes mapping Stake memory stake = stakes[i]; delete stakes[i]; // Add the token to the owner's balance _safeMint(stake.owner, i); } } } /** * @notice Return the royalties receiver * * @return the address of the royalties recipient */ function royaltiesReceiver() external view returns (address) { return _royaltiesReceiver; } /** * @notice Changes the royalties' recipient address (in case rights are transferred for instance) * * @param newRoyaltiesReceiver - address of the new royalties recipient */ function setRoyaltiesReceiver(address newRoyaltiesReceiver) external onlyOwner { require(newRoyaltiesReceiver != _royaltiesReceiver); // not the same address _royaltiesReceiver = newRoyaltiesReceiver; } /** * @notice Called with the sale price to determine how much royalty is owed and to whom. * * @param _tokenId - the NFT asset queried for royalty information * @param _salePrice - sale price of the NFT asset specified by _tokenId * * @return receiver - address of who should be sent the royalty payment * @return royaltyAmount - the royalty payment amount for _value sale price */ function royaltyInfo(uint256 _tokenId, uint256 _salePrice) external view returns (address receiver, uint256 royaltyAmount) { uint256 _royalties = (_salePrice * royaltiesPercentage) / 100; return (_royaltiesReceiver, _royalties); } /** * @notice Add a whitelisted address * * @param _whitelist The whitelist address * **/ function addWhitelist(address _whitelist) external onlyOwner { whitelisted.push(_whitelist); } function addBulkWhitelist(address[] memory _whitelists) external onlyOwner { for (uint256 i = 0; i < _whitelists.length; i++) { whitelisted.push(_whitelists[i]); } } /** * @notice Update all whitelists * * @param _whitelists Array of whitelist address * **/ function setWhitelists(address[] memory _whitelists) external onlyOwner { whitelisted = _whitelists; } /** * @notice Get all whitelists * * @return Return all the whitelists * **/ function getWhitelists() external view returns (address[] memory) { return whitelisted; } /** * @notice Remove a whitelisted address * * @param _whitelist The whitelist address * **/ function removeWhitelist(address _whitelist) external onlyOwner { for (uint256 i = 0; i < whitelisted.length; i++) { if (whitelisted[i] == _whitelist) { delete whitelisted[i]; } } } /** * @notice Change the number of NFTs that an address can mint * * @param _maxMintAllowed The number of NFTs that an address can mint **/ function changeMaxMintAllowed(uint _maxMintAllowed) external onlyOwner { max_mint_allowed = _maxMintAllowed; } /** * @notice Change the price of one NFT for the presale * * @param _pricePresale The new price of one NFT for the presale **/ function changePricePresale(uint _pricePresale) external onlyOwner { pricePresale = _pricePresale; } /** * @notice Change the price of one NFT for the sale * * @param _number The number of NFTS you want to update * @param _priceSale The new price of one NFT for the sale **/ function changePriceSale(uint _number, uint _priceSale) external onlyOwner { priceSale[_number] = _priceSale; } /** * @notice Change the base URI * * @param _newBaseURI The new base URI **/ function setBaseUri(string memory _newBaseURI) external onlyOwner { _baseURIVariable = _newBaseURI; } /** * @notice Change the not revealed URI * * @param _notRevealedURI The new not revealed URI **/ function setNotRevealURI(string memory _notRevealedURI) external onlyOwner { notRevealedURI = _notRevealedURI; } /** * @notice Allows to set the revealed variable to true **/ function reveal() external onlyOwner { revealed = true; } /** * @notice Return URI of the NFTs * * @return The URI of the NFTs **/ function _baseURI() internal view virtual override returns (string memory) { require(revealed == true, "The base URI has not been revealed yet"); return _baseURIVariable; } /** * @notice Allows to change the base extension of the metadatas files * * @param _baseExtension the new extension of the metadatas files **/ function setBaseExtension(string memory _baseExtension) external onlyOwner { baseExtension = _baseExtension; } // /** // * @notice Allows to change the sellinStep to Presale // **/ // function setUpPresale() external onlyOwner { // sellingStep = Steps.Presale; // } /** * @notice Allows to change the sellinStep to Sale **/ function setUpSale() external onlyOwner { // require( // sellingStep == Steps.Presale, // "You can fast forward to the sale, please do the presale before." // ); sellingStep = Steps.Sale; } /** * @notice Allows to mint one NFT if whitelisted * **/ // function presaleMint() external payable nonReentrant whenNotPaused { // //Are we in Presale ? // require(sellingStep == Steps.Presale, "Presale has not started yet."); // //Did this account already mint an NFT ? // require( // nftsPerWallet[msg.sender] < 1, // "You can only get 1 NFT on the Presale" // ); // //Is this user on the whitelist ? // require(isWhiteListed(), "Not on the whitelist"); // //Get the price of one NFT during the Presale // uint price = pricePresale; // //Did the user send enought Ethers ? // require(msg.value >= price, "Not enought funds."); // //Increment the number of NFTs this user minted // nftsPerWallet[msg.sender]++; // //Mint the user NFT // _safeMint(msg.sender, _nftIdCounter.current()); // //Increment the Id of the next NFT to mint // _nftIdCounter.increment(); // } /** * @notice Allows to mint NFTs * * @param _ammount The ammount of NFTs the user wants to mint **/ function saleMint(uint256 _ammount) external payable nonReentrant whenNotPaused { //Is this user on the whitelist ? require(isWhiteListed(), "Not on the whitelist"); // Check if the _ammount is not greater than the last priceSale uint price; if (_ammount > 3) { price = priceSale[3]; } else { price = priceSale[_ammount]; } //Get the price of one NFT in Sale //If everything has been bought require(sellingStep != Steps.SoldOut, "Sorry, no NFTs left."); //If Sale didn't start yet require(sellingStep == Steps.Sale, "Sorry, sale has not started yet."); //Did the user then enought Ethers to buy ammount NFTs ? require(msg.value >= price * _ammount, "Not enought funds."); //The user can only mint max 3 NFTs require( _ammount <= max_mint_allowed, "You can't mint more than 3 NFT's" ); // Verify that the user don't mint more than 3 NFTS in total require( nftsPerWallet[msg.sender] + _ammount <= max_mint_allowed, "You can't mint more than 3 NFT's per wallet" ); //If the user try to mint any non-existent token require( _nftIdCounter.current() + _ammount - 1 <= MAX_SUPPLY, "Sale is almost done and we don't have enought NFTs left." ); //Add the ammount of NFTs minted by the user to the total he minted nftsPerWallet[msg.sender] += _ammount; //If this account minted the last NFTs available if (_nftIdCounter.current() + _ammount - 1 == MAX_SUPPLY) { sellingStep = Steps.SoldOut; } //Minting all the account NFTs for (uint i = 1; i <= _ammount; i++) { _safeMint(msg.sender, _nftIdCounter.current()); _nftIdCounter.increment(); } } /** * @notice Allows to gift one NFT to an address * * @param _account The account of the happy new owner of one NFT **/ function gift(address _account) external onlyOwner { uint supply = _nftIdCounter.current(); require(supply <= MAX_SUPPLY, "Sold out"); _safeMint(_account, supply); _nftIdCounter.increment(); } function setCancelWhitelist(bool _status) external onlyOwner { cancelWhitelist = _status; } /** * @notice Return true or false if the account is whitelisted or not * * @return true or false if the account is whitelisted or not **/ function isWhiteListed() internal view returns (bool) { if(cancelWhitelist) { return true; } bool inWhitelist = false; for (uint256 i = 0; i < whitelisted.length; i++) { if (whitelisted[i] == msg.sender) { inWhitelist = true; } } return inWhitelist; } /** * @notice Allows to get the complete URI of a specific NFT by his ID * * @param _nftId The id of the NFT * * @return The token URI of the NFT which has _nftId Id **/ function tokenURI(uint _nftId) public view override(ERC721) returns (string memory) { require(_exists(_nftId), "This NFT doesn't exist."); if (revealed == false) { return notRevealedURI; } string memory currentBaseURI = _baseURI(); return bytes(currentBaseURI).length > 0 ? string( abi.encodePacked( currentBaseURI, _nftId.toString(), baseExtension ) ) : ""; } function withdrawAll(address _to) public onlyOwner { payable(_to).transfer(address(this).balance); } function contractBalance() public view onlyOwner returns (uint256) { return address(this).balance; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"_theBaseURI","type":"string"},{"internalType":"string","name":"_notRevealedURI","type":"string"},{"internalType":"address","name":"_initialRoyaltiesReceiver","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","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"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_whitelists","type":"address[]"}],"name":"addBulkWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_whitelist","type":"address"}],"name":"addWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxMintAllowed","type":"uint256"}],"name":"changeMaxMintAllowed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pricePresale","type":"uint256"}],"name":"changePricePresale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_number","type":"uint256"},{"internalType":"uint256","name":"_priceSale","type":"uint256"}],"name":"changePriceSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractBalance","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":[],"name":"getWhitelists","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"gift","outputs":[],"stateMutability":"nonpayable","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":"max_mint_allowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"notRevealedURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pricePresale","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"priceSale","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_whitelist","type":"address"}],"name":"removeWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"reveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"royaltiesPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"royaltiesReceiver","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"royaltyAmount","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"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":"uint256","name":"_ammount","type":"uint256"}],"name":"saleMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"sellingStep","outputs":[{"internalType":"enum OYABUN.Steps","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_baseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_status","type":"bool"}],"name":"setCancelWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_notRevealedURI","type":"string"}],"name":"setNotRevealURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRoyaltiesReceiver","type":"address"}],"name":"setRoyaltiesReceiver","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_status","type":"bool"}],"name":"setStakingStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setUpSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_whitelists","type":"address[]"}],"name":"setWhitelists","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"stakeNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"stakes","outputs":[{"internalType":"uint256","name":"createdAt","type":"uint256"},{"internalType":"address","name":"owner","type":"address"},{"internalType":"bool","name":"instanciated","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"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":"_nftId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"unPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unstakeAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"unstakeNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"whitelisted","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"}],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
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)
000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000563cb1729c1b06e07567482702a3eb2e9cc5fe860000000000000000000000000000000000000000000000000000000000000036697066733a2f2f516d566475336555426731594e5a314345546e48624775796a33486575366b336d584832584e57335a4e48646d6e2f00000000000000000000000000000000000000000000000000000000000000000000000000000000003e697066733a2f2f516d566475336555426731594e5a314345546e48624775796a33486575366b336d584832584e57335a4e48646d6e2f6e6f742e6a736f6e0000
-----Decoded View---------------
Arg [0] : _theBaseURI (string): ipfs://QmVdu3eUBg1YNZ1CETnHbGuyj3Heu6k3mXH2XNW3ZNHdmn/
Arg [1] : _notRevealedURI (string): ipfs://QmVdu3eUBg1YNZ1CETnHbGuyj3Heu6k3mXH2XNW3ZNHdmn/not.json
Arg [2] : _initialRoyaltiesReceiver (address): 0x563cB1729C1B06E07567482702a3EB2E9cc5fe86
-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 000000000000000000000000563cb1729c1b06e07567482702a3eb2e9cc5fe86
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000036
Arg [4] : 697066733a2f2f516d566475336555426731594e5a314345546e48624775796a
Arg [5] : 33486575366b336d584832584e57335a4e48646d6e2f00000000000000000000
Arg [6] : 000000000000000000000000000000000000000000000000000000000000003e
Arg [7] : 697066733a2f2f516d566475336555426731594e5a314345546e48624775796a
Arg [8] : 33486575366b336d584832584e57335a4e48646d6e2f6e6f742e6a736f6e0000
Deployed Bytecode Sourcemap
79876:16624:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43395:40;21484:10;43395:40;;;-1:-1:-1;;;;;9780:32:1;;;9762:51;;43425:9:0;9844:2:1;9829:18;;9822:34;9735:18;43395:40:0;;;;;;;79876:16624;;;;;73616:224;;;;;;;;;;-1:-1:-1;73616:224:0;;;;;:::i;:::-;;:::i;:::-;;;11467:14:1;;11460:22;11442:41;;11430:2;11415:18;73616:224:0;;;;;;;;83454:68;;;;;;;;;;;;;:::i;:::-;;60350:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;61863:171::-;;;;;;;;;;-1:-1:-1;61863:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;9536:32:1;;;9518:51;;9506:2;9491:18;61863:171:0;9372:203:1;61380:417:0;;;;;;;;;;-1:-1:-1;61380:417:0;;;;;:::i;:::-;;:::i;74256:113::-;;;;;;;;;;-1:-1:-1;74344:10:0;:17;74256:113;;;26750:25:1;;;26738:2;26723:18;74256:113:0;26604:177:1;45916:453:0;;;;;;;;;;-1:-1:-1;45916:453:0;;;;;:::i;:::-;;:::i;90874:247::-;;;;;;;;;;;;;:::i;62563:336::-;;;;;;;;;;-1:-1:-1;62563:336:0;;;;;:::i;:::-;;:::i;86834:285::-;;;;;;;;;;-1:-1:-1;86834:285:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;9780:32:1;;;9762:51;;9844:2;9829:18;;9822:34;;;;9735:18;86834:285:0;9580:282:1;73924:256:0;;;;;;;;;;-1:-1:-1;73924:256:0;;;;;:::i;:::-;;:::i;80372:38::-;;;;;;;;;;;;80406:4;80372:38;;85260:428;;;;;;;;;;;;;:::i;87700:116::-;;;;;;;;;;-1:-1:-1;87700:116:0;;;;;:::i;:::-;;:::i;83315:67::-;;;;;;;;;;;;;:::i;43526:91::-;;;;;;;;;;-1:-1:-1;43597:12:0;;43526:91;;80167:75;;;;;;;;;;-1:-1:-1;80167:75:0;;;;;:::i;:::-;;:::i;88883:114::-;;;;;;;;;;-1:-1:-1;88883:114:0;;;;;:::i;:::-;;:::i;44655:135::-;;;;;;;;;;-1:-1:-1;44655:135:0;;;;;:::i;:::-;-1:-1:-1;;;;;44752:21:0;;;44725:7;44752:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;44655:135;62970:185;;;;;;;;;;-1:-1:-1;62970:185:0;;;;;:::i;:::-;;:::i;46637:514::-;;;;;;;;;;-1:-1:-1;46637:514:0;;;;;:::i;:::-;;:::i;74446:233::-;;;;;;;;;;-1:-1:-1;74446:233:0;;;;;:::i;:::-;;:::i;81080:28::-;;;;;;;;;;-1:-1:-1;81080:28:0;;;;;;;;88594:124;;;;;;;;;;-1:-1:-1;88594:124:0;;;;;:::i;:::-;;:::i;89704:126::-;;;;;;;;;;-1:-1:-1;89704:126:0;;;;;:::i;:::-;;:::i;23291:86::-;;;;;;;;;;-1:-1:-1;23362:7:0;;;;23291:86;;60061:222;;;;;;;;;;-1:-1:-1;60061:222:0;;;;;:::i;:::-;;:::i;83760:116::-;;;;;;;;;;-1:-1:-1;83760:116:0;;;;;:::i;:::-;;:::i;59792:207::-;;;;;;;;;;-1:-1:-1;59792:207:0;;;;;:::i;:::-;;:::i;26156:103::-;;;;;;;;;;;;;:::i;80894:28::-;;;;;;;;;;;;;:::i;88170:247::-;;;;;;;;;;-1:-1:-1;88170:247:0;;;;;:::i;:::-;;:::i;96383:114::-;;;;;;;;;;;;;:::i;44881:100::-;;;;;;;;;;-1:-1:-1;44881:100:0;;;;;:::i;:::-;;:::i;92342:1999::-;;;;;;:::i;:::-;;:::i;25508:87::-;;;;;;;;;;-1:-1:-1;25581:6:0;;-1:-1:-1;;;;;25581:6:0;25508:87;;80541:33;;;;;;;;;;;;;;;;60519:104;;;;;;;;;;;;;:::i;80731:38::-;;;;;;;;;;-1:-1:-1;80731:38:0;;;;;:::i;:::-;;;;;;;;;;;;;;44377:109;;;;;;;;;;-1:-1:-1;44377:109:0;;;;;:::i;:::-;-1:-1:-1;;;;;44460:18:0;44433:7;44460:18;;;:9;:18;;;;;;;44377:109;89454:115;;;;;;;;;;-1:-1:-1;89454:115:0;;;;;:::i;:::-;;:::i;62106:155::-;;;;;;;;;;-1:-1:-1;62106:155:0;;;;;:::i;:::-;;:::i;85823:105::-;;;;;;;;;;-1:-1:-1;85902:18:0;;-1:-1:-1;;;;;85902:18:0;85823:105;;45071:225;;;;;;;;;;-1:-1:-1;45071:225:0;;;;;:::i;:::-;;:::i;89917:71::-;;;;;;;;;;;;;:::i;89214:125::-;;;;;;;;;;-1:-1:-1;89214:125:0;;;;;:::i;:::-;;:::i;86142:248::-;;;;;;;;;;-1:-1:-1;86142:248:0;;;;;:::i;:::-;;:::i;94740:105::-;;;;;;;;;;-1:-1:-1;94740:105:0;;;;;:::i;:::-;;:::i;63226:323::-;;;;;;;;;;-1:-1:-1;63226:323:0;;;;;:::i;:::-;;:::i;83650:102::-;;;;;;;;;;-1:-1:-1;83650:102:0;;;;;:::i;:::-;;:::i;80467:32::-;;;;;;;;;;;;;;;;84405:120;;;;;;;;;;-1:-1:-1;84405:120:0;;;;;:::i;:::-;;:::i;87931:103::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;45456:260::-;;;;;;;;;;-1:-1:-1;45456:260:0;;;;;:::i;:::-;;:::i;80999:37::-;;;;;;;;;;;;;:::i;95606:647::-;;;;;;;;;;-1:-1:-1;95606:647:0;;;;;:::i;:::-;;:::i;81872:47::-;;;;;;;;;;;;81918:1;81872:47;;81282:24;;;;;;;;;;-1:-1:-1;81282:24:0;;;;;;;;;;;;;;;;;;:::i;94499:233::-;;;;;;;;;;-1:-1:-1;94499:233:0;;;;;:::i;:::-;;:::i;87368:201::-;;;;;;;;;;-1:-1:-1;87368:201:0;;;;;:::i;:::-;;:::i;44173:105::-;;;;;;;;;;-1:-1:-1;44173:105:0;;;;;:::i;:::-;-1:-1:-1;;;;;44254:16:0;44227:7;44254:16;;;:7;:16;;;;;;;44173:105;82191:39;;;;;;;;;;-1:-1:-1;82191:39:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;82191:39:0;;;-1:-1:-1;;;82191:39:0;;;;;;;;;;26982:25:1;;;-1:-1:-1;;;;;27043:32:1;;;27038:2;27023:18;;27016:60;27119:14;27112:22;27092:18;;;27085:50;26970:2;26955:18;82191:39:0;26786:355:1;43963:119:0;;;;;;;;;;-1:-1:-1;43963:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;44048:26:0;44021:7;44048:26;;;:19;:26;;;;;;;43963:119;90474:124;;;;;;;;;;-1:-1:-1;90474:124:0;;;;;:::i;:::-;;:::i;43711:95::-;;;;;;;;;;-1:-1:-1;43784:14:0;;43711:95;;62332:164;;;;;;;;;;-1:-1:-1;62332:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;62453:25:0;;;62429:4;62453:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;62332:164;26414:201;;;;;;;;;;-1:-1:-1;26414:201:0;;;;;:::i;:::-;;:::i;87252:108::-;;;;;;;;;;-1:-1:-1;87252:108:0;;;;;:::i;:::-;;:::i;96261:114::-;;;;;;;;;;-1:-1:-1;96261:114:0;;;;;:::i;:::-;;:::i;73616:224::-;73718:4;-1:-1:-1;;;;;;73742:50:0;;-1:-1:-1;;;73742:50:0;;:90;;;73796:36;73820:11;73796:23;:36::i;:::-;73735:97;73616:224;-1:-1:-1;;73616:224:0:o;83454:68::-;25394:13;:11;:13::i;:::-;83504:10:::1;:8;:10::i;:::-;83454:68::o:0;60350:100::-;60404:13;60437:5;60430:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;60350:100;:::o;61863:171::-;61939:7;61959:23;61974:7;61959:14;:23::i;:::-;-1:-1:-1;62002:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;62002:24:0;;61863:171::o;61380:417::-;61461:13;61477:23;61492:7;61477:14;:23::i;:::-;61461:39;;61525:5;-1:-1:-1;;;;;61519:11:0;:2;-1:-1:-1;;;;;61519:11:0;;;61511:57;;;;-1:-1:-1;;;61511:57:0;;22570:2:1;61511:57:0;;;22552:21:1;22609:2;22589:18;;;22582:30;22648:34;22628:18;;;22621:62;-1:-1:-1;;;22699:18:1;;;22692:31;22740:19;;61511:57:0;;;;;;;;;21484:10;-1:-1:-1;;;;;61603:21:0;;;;:62;;-1:-1:-1;61628:37:0;61645:5;21484:10;62332:164;:::i;61628:37::-;61581:174;;;;-1:-1:-1;;;61581:174:0;;19887:2:1;61581:174:0;;;19869:21:1;19926:2;19906:18;;;19899:30;19965:34;19945:18;;;19938:62;20036:32;20016:18;;;20009:60;20086:19;;61581:174:0;19685:426:1;61581:174:0;61768:21;61777:2;61781:7;61768:8;:21::i;:::-;61450:347;61380:417;;:::o;45916:453::-;-1:-1:-1;;;;;45992:16:0;;46011:1;45992:16;;;:7;:16;;;;;;45984:71;;;;-1:-1:-1;;;45984:71:0;;;;;;;:::i;:::-;46068:15;46086:19;46097:7;46086:10;:19::i;:::-;46068:37;-1:-1:-1;46126:12:0;46118:68;;;;-1:-1:-1;;;46118:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;46199:18:0;;;;;;:9;:18;;;;;:29;;46221:7;;46199:18;:29;;46221:7;;46199:29;:::i;:::-;;;;;;;;46257:7;46239:14;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;46277:35:0;;-1:-1:-1;46295:7:0;46304;46277:17;:35::i;:::-;46328:33;;;-1:-1:-1;;;;;9780:32:1;;9762:51;;9844:2;9829:18;;9822:34;;;46328:33:0;;9735:18:1;46328:33:0;;;;;;;45973:396;45916:453;:::o;90874:247::-;25394:13;:11;:13::i;:::-;91089:11:::1;:24:::0;;-1:-1:-1;;91089:24:0::1;::::0;::::1;::::0;;90874:247::o;62563:336::-;62758:41;21484:10;62791:7;62758:18;:41::i;:::-;62750:100;;;;-1:-1:-1;;;62750:100:0;;;;;;;:::i;:::-;62863:28;62873:4;62879:2;62883:7;62863:9;:28::i;86834:285::-;86943:16;;;87058:3;87022:32;81918:1;87022:10;:32;:::i;:::-;87021:40;;;;:::i;:::-;87080:18;;-1:-1:-1;;;;;87080:18:0;;87000:61;;-1:-1:-1;86834:285:0;-1:-1:-1;;;;86834:285:0:o;73924:256::-;74021:7;74057:23;74074:5;74057:16;:23::i;:::-;74049:5;:31;74041:87;;;;-1:-1:-1;;;74041:87:0;;13312:2:1;74041:87:0;;;13294:21:1;13351:2;13331:18;;;13324:30;13390:34;13370:18;;;13363:62;-1:-1:-1;;;13441:18:1;;;13434:41;13492:19;;74041:87:0;13110:407:1;74041:87:0;-1:-1:-1;;;;;;74146:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;73924:256::o;85260:428::-;25394:13;:11;:13::i;:::-;85316:9:::1;85312:369;85335:13;9002:14:::0;85331:1:::1;:27;85312:369;;;85384:9;::::0;;;:6:::1;:9;::::0;;;;:22:::1;;::::0;-1:-1:-1;;;85384:22:0;::::1;;;85380:290;;;85488:18;85509:9:::0;;;:6:::1;:9;::::0;;;;;;;85488:30;;::::1;::::0;::::1;::::0;;;;;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;85488:30:0;::::1;::::0;;::::1;::::0;;;::::1;-1:-1:-1::0;;;85488:30:0;::::1;;;;::::0;;;;;;;85544:9;;;;;;;85537:16;;;-1:-1:-1;;;;;;85537:16:0;;;;;85639:11;85629:25:::1;::::0;85516:1;85629:9:::1;:25::i;:::-;85408:262;85380:290;85360:3:::0;::::1;::::0;::::1;:::i;:::-;;;;85312:369;;;;85260:428::o:0;87700:116::-;25394:13;:11;:13::i;:::-;87783:25;;::::1;::::0;:11:::1;::::0;:25:::1;::::0;::::1;::::0;::::1;:::i;:::-;;87700:116:::0;:::o;83315:67::-;25394:13;:11;:13::i;:::-;83366:8:::1;:6;:8::i;80167:75::-:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;80167:75:0;;-1:-1:-1;80167:75:0;:::o;88883:114::-;25394:13;:11;:13::i;:::-;88961:12:::1;:28:::0;88883:114::o;62970:185::-;63108:39;63125:4;63131:2;63135:7;63108:39;;;;;;;;;;;;:16;:39::i;46637:514::-;-1:-1:-1;;;;;46719:16:0;;46738:1;46719:16;;;:7;:16;;;;;;46711:71;;;;-1:-1:-1;;;46711:71:0;;;;;;;:::i;:::-;46795:15;46813:26;46824:5;46831:7;46813:10;:26::i;:::-;46795:44;-1:-1:-1;46860:12:0;46852:68;;;;-1:-1:-1;;;46852:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;46933:21:0;;;;;;;:14;:21;;;;;;;;:30;;;;;;;;;;;:41;;46967:7;;46933:21;:41;;46967:7;;46933:41;:::i;:::-;;;;-1:-1:-1;;;;;;;46985:26:0;;;;;;:19;:26;;;;;:37;;47015:7;;46985:26;:37;;47015:7;;46985:37;:::i;:::-;;;;-1:-1:-1;47035:47:0;;-1:-1:-1;47058:5:0;47065:7;47074;47035:22;:47::i;:::-;47098:45;;;-1:-1:-1;;;;;9780:32:1;;;9762:51;;9844:2;9829:18;;9822:34;;;47098:45:0;;;;;9735:18:1;47098:45:0;;;;;;;46700:451;46637:514;;:::o;74446:233::-;74521:7;74557:30;74344:10;:17;;74256:113;74557:30;74549:5;:38;74541:95;;;;-1:-1:-1;;;74541:95:0;;24073:2:1;74541:95:0;;;24055:21:1;24112:2;24092:18;;;24085:30;24151:34;24131:18;;;24124:62;-1:-1:-1;;;24202:18:1;;;24195:42;24254:19;;74541:95:0;23871:408:1;74541:95:0;74654:10;74665:5;74654:17;;;;;;;;:::i;:::-;;;;;;;;;74647:24;;74446:233;;;:::o;88594:124::-;25394:13;:11;:13::i;:::-;88676:16:::1;:34:::0;88594:124::o;89704:126::-;25394:13;:11;:13::i;:::-;89790:32;;::::1;::::0;:14:::1;::::0;:32:::1;::::0;::::1;::::0;::::1;:::i;60061:222::-:0;60133:7;60169:16;;;:7;:16;;;;;;-1:-1:-1;;;;;60169:16:0;60204:19;60196:56;;;;-1:-1:-1;;;60196:56:0;;22217:2:1;60196:56:0;;;22199:21:1;22256:2;22236:18;;;22229:30;-1:-1:-1;;;22275:18:1;;;22268:54;22339:18;;60196:56:0;22015:348:1;83760:116:0;22896:19;:17;:19::i;:::-;83581:17:::1;::::0;-1:-1:-1;;;83581:17:0;::::1;;;83573:49;;;::::0;-1:-1:-1;;;83573:49:0;;18784:2:1;83573:49:0::1;::::0;::::1;18766:21:1::0;18823:2;18803:18;;;18796:30;-1:-1:-1;;;18842:18:1;;;18835:49;18901:18;;83573:49:0::1;18582:343:1::0;83573:49:0::1;83849:19:::2;83859:8;83849:9;:19::i;59792:207::-:0;59864:7;-1:-1:-1;;;;;59892:19:0;;59884:73;;;;-1:-1:-1;;;59884:73:0;;19477:2:1;59884:73:0;;;19459:21:1;19516:2;19496:18;;;19489:30;19555:34;19535:18;;;19528:62;-1:-1:-1;;;19606:18:1;;;19599:39;19655:19;;59884:73:0;19275:405:1;59884:73:0;-1:-1:-1;;;;;;59975:16:0;;;;;:9;:16;;;;;;;59792:207::o;26156:103::-;25394:13;:11;:13::i;:::-;26221:30:::1;26248:1;26221:18;:30::i;80894:28::-:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;88170:247::-;25394:13;:11;:13::i;:::-;88250:9:::1;88245:165;88269:11;:18:::0;88265:22;::::1;88245:165;;;88331:10;-1:-1:-1::0;;;;;88313:28:0::1;:11;88325:1;88313:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;-1:-1:-1;;;;;88313:14:0::1;:28;88309:90;;;88369:11;88381:1;88369:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;88362:21:::0;;-1:-1:-1;;;;;;88362:21:0::1;::::0;;88309:90:::1;88289:3:::0;::::1;::::0;::::1;:::i;:::-;;;;88245:165;;96383:114:::0;96441:7;25394:13;:11;:13::i;:::-;-1:-1:-1;96468:21:0::1;96383:114:::0;:::o;44881:100::-;44932:7;44959;44967:5;44959:14;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;44959:14:0;;44881:100;-1:-1:-1;;44881:100:0:o;92342:1999::-;1847:1;2445:7;;:19;;2437:63;;;;-1:-1:-1;;;2437:63:0;;25724:2:1;2437:63:0;;;25706:21:1;25763:2;25743:18;;;25736:30;25802:33;25782:18;;;25775:61;25853:18;;2437:63:0;25522:355:1;2437:63:0;1847:1;2578:7;:18;22896:19:::1;:17;:19::i;:::-;92525:15:::2;:13;:15::i;:::-;92517:48;;;::::0;-1:-1:-1;;;92517:48:0;;14550:2:1;92517:48:0::2;::::0;::::2;14532:21:1::0;14589:2;14569:18;;;14562:30;-1:-1:-1;;;14608:18:1;;;14601:50;14668:18;;92517:48:0::2;14348:344:1::0;92517:48:0::2;92649:10;92685:1;92674:8;:12;92670:125;;;-1:-1:-1::0;92721:1:0::2;92711:12;::::0;:9:::2;:12;::::0;;;92670:125:::2;;;-1:-1:-1::0;92764:19:0::2;::::0;;;:9:::2;:19;::::0;;;;;92670:125:::2;92913:13;92898:11;::::0;::::2;::::0;::::2;;;:28;::::0;::::2;;;;;;:::i;:::-;;;92890:61;;;::::0;-1:-1:-1;;;92890:61:0;;20679:2:1;92890:61:0::2;::::0;::::2;20661:21:1::0;20718:2;20698:18;;;20691:30;-1:-1:-1;;;20737:18:1;;;20730:50;20797:18;;92890:61:0::2;20477:344:1::0;92890:61:0::2;93021:10;93006:11;::::0;::::2;::::0;::::2;;;:25;::::0;::::2;;;;;;:::i;:::-;;92998:70;;;::::0;-1:-1:-1;;;92998:70:0;;26084:2:1;92998:70:0::2;::::0;::::2;26066:21:1::0;;;26103:18;;;26096:30;26162:34;26142:18;;;26135:62;26214:18;;92998:70:0::2;25882:356:1::0;92998:70:0::2;93166:16;93174:8:::0;93166:5;:16:::2;:::i;:::-;93153:9;:29;;93145:60;;;::::0;-1:-1:-1;;;93145:60:0;;12612:2:1;93145:60:0::2;::::0;::::2;12594:21:1::0;12651:2;12631:18;;;12624:30;-1:-1:-1;;;12670:18:1;;;12663:48;12728:18;;93145:60:0::2;12410:342:1::0;93145:60:0::2;93295:16;;93283:8;:28;;93261:110;;;::::0;-1:-1:-1;;;93261:110:0;;26445:2:1;93261:110:0::2;::::0;::::2;26427:21:1::0;;;26464:18;;;26457:30;26523:34;26503:18;;;26496:62;26575:18;;93261:110:0::2;26243:356:1::0;93261:110:0::2;93514:16;::::0;93488:10:::2;93474:25;::::0;;;:13:::2;:25;::::0;;;;;:36:::2;::::0;93502:8;;93474:36:::2;:::i;:::-;:56;;93452:149;;;::::0;-1:-1:-1;;;93452:149:0;;24486:2:1;93452:149:0::2;::::0;::::2;24468:21:1::0;24525:2;24505:18;;;24498:30;24564:34;24544:18;;;24537:62;-1:-1:-1;;;24615:18:1;;;24608:41;24666:19;;93452:149:0::2;24284:407:1::0;93452:149:0::2;80406:4;93729:1;93718:8;93692:23;:13;9002:14:::0;;8910:114;93692:23:::2;:34;;;;:::i;:::-;:38;;;;:::i;:::-;:52;;93670:158;;;::::0;-1:-1:-1;;;93670:158:0;;21431:2:1;93670:158:0::2;::::0;::::2;21413:21:1::0;21470:2;21450:18;;;21443:30;21509:34;21489:18;;;21482:62;21580:26;21560:18;;;21553:54;21624:19;;93670:158:0::2;21229:420:1::0;93670:158:0::2;93930:10;93916:25;::::0;;;:13:::2;:25;::::0;;;;:37;;93945:8;;93916:25;:37:::2;::::0;93945:8;;93916:37:::2;:::i;:::-;::::0;;;-1:-1:-1;80406:4:0::2;::::0;-1:-1:-1;94063:1:0::2;94052:8:::0;94026:23:::2;:13;9002:14:::0;;8910:114;94026:23:::2;:34;;;;:::i;:::-;:38;;;;:::i;:::-;:52;94022:112;;;94095:11;:27:::0;;-1:-1:-1;;94095:27:0::2;::::0;::::2;::::0;;94022:112:::2;94198:1;94184:150;94206:8;94201:1;:13;94184:150;;94236:46;94246:10;94258:23;:13;9002:14:::0;;8910:114;94258:23:::2;94236:9;:46::i;:::-;94297:25;:13;9121:19:::0;;9139:1;9121:19;;;9032:127;94297:25:::2;94216:3:::0;::::2;::::0;::::2;:::i;:::-;;;;94184:150;;;-1:-1:-1::0;;1803:1:0;2757:7;:22;-1:-1:-1;92342:1999:0:o;60519:104::-;60575:13;60608:7;60601:14;;;;;:::i;89454:115::-;25394:13;:11;:13::i;:::-;89531:30;;::::1;::::0;:16:::1;::::0;:30:::1;::::0;::::1;::::0;::::1;:::i;62106:155::-:0;62201:52;21484:10;62234:8;62244;62201:18;:52::i;45071:225::-;45129:7;45149:21;45197:15;43784:14;;;43711:95;45197:15;45173:39;;:21;:39;:::i;:::-;45149:63;;45230:58;45246:7;45255:13;45270:17;45279:7;-1:-1:-1;;;;;44460:18:0;44433:7;44460:18;;;:9;:18;;;;;;;44377:109;45270:17;45230:15;:58::i;:::-;45223:65;45071:225;-1:-1:-1;;;45071:225:0:o;89917:71::-;25394:13;:11;:13::i;:::-;89965:8:::1;:15:::0;;-1:-1:-1;;89965:15:0::1;89976:4;89965:15;::::0;;89917:71::o;89214:125::-;25394:13;:11;:13::i;:::-;89300:18:::1;::::0;;;:9:::1;:18;::::0;;;;;:31;89214:125::o;86142:248::-;25394:13;:11;:13::i;:::-;86287:18:::1;::::0;-1:-1:-1;;;;;86263:42:0;;::::1;86287:18:::0;::::1;86263:42;;86255:51;;;::::0;::::1;;86341:18;:41:::0;;-1:-1:-1;;;;;;86341:41:0::1;-1:-1:-1::0;;;;;86341:41:0;;;::::1;::::0;;;::::1;::::0;;86142:248::o;94740:105::-;25394:13;:11;:13::i;:::-;94812:15:::1;:25:::0;;;::::1;;-1:-1:-1::0;;;94812:25:0::1;-1:-1:-1::0;;;;94812:25:0;;::::1;::::0;;;::::1;::::0;;94740:105::o;63226:323::-;63400:41;21484:10;63433:7;63400:18;:41::i;:::-;63392:100;;;;-1:-1:-1;;;63392:100:0;;;;;;;:::i;:::-;63503:38;63517:4;63523:2;63527:7;63536:4;63503:13;:38::i;:::-;63226:323;;;;:::o;83650:102::-;25394:13;:11;:13::i;:::-;83717:17:::1;:27:::0;;;::::1;;-1:-1:-1::0;;;83717:27:0::1;-1:-1:-1::0;;;;83717:27:0;;::::1;::::0;;;::::1;::::0;;83650:102::o;84405:120::-;22896:19;:17;:19::i;:::-;83581:17:::1;::::0;-1:-1:-1;;;83581:17:0;::::1;;;83573:49;;;::::0;-1:-1:-1;;;83573:49:0;;18784:2:1;83573:49:0::1;::::0;::::1;18766:21:1::0;18823:2;18803:18;;;18796:30;-1:-1:-1;;;18842:18:1;;;18835:49;18901:18;;83573:49:0::1;18582:343:1::0;83573:49:0::1;84496:21:::2;84508:8;84496:11;:21::i;87931:103::-:0;87979:16;88015:11;88008:18;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;88008:18:0;;;;;;;;;;;;;;;;;;;;;;87931:103;:::o;45456:260::-;-1:-1:-1;;;;;44048:26:0;;45528:7;44048:26;;;:19;:26;;;;;;45528:7;;45572:30;;-1:-1:-1;;;45572:30:0;;45596:4;45572:30;;;9518:51:1;-1:-1:-1;;;;;45572:15:0;;;;;9491:18:1;;45572:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;;;:::i;:::-;-1:-1:-1;;;;;44752:21:0;;;44725:7;44752:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;45548:77;;-1:-1:-1;45643:65:0;;45659:7;;45548:77;;45230:15;:58::i;45643:65::-;45636:72;45456:260;-1:-1:-1;;;;45456:260:0:o;80999:37::-;;;;;;;:::i;95606:647::-;65121:4;65145:16;;;:7;:16;;;;;;95711:13;;-1:-1:-1;;;;;65145:16:0;95742:51;;;;-1:-1:-1;;;95742:51:0;;14899:2:1;95742:51:0;;;14881:21:1;14938:2;14918:18;;;14911:30;14977:25;14957:18;;;14950:53;15020:18;;95742:51:0;14697:347:1;95742:51:0;95808:8;;;;95804:71;;95849:14;95842:21;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;95606:647;;;:::o;95804:71::-;95887:28;95918:10;:8;:10::i;:::-;95887:41;;95990:1;95965:14;95959:28;:32;:286;;;;;;;;;;;;;;;;;96083:14;96124:17;:6;:15;:17::i;:::-;96168:13;96040:164;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;95939:306;95606:647;-1:-1:-1;;;95606:647:0:o;94499:233::-;25394:13;:11;:13::i;:::-;94561:11:::1;94575:23;:13;9002:14:::0;;8910:114;94575:23:::1;94561:37;;80406:4;94617:6;:20;;94609:41;;;::::0;-1:-1:-1;;;94609:41:0;;23379:2:1;94609:41:0::1;::::0;::::1;23361:21:1::0;23418:1;23398:18;;;23391:29;-1:-1:-1;;;23436:18:1;;;23429:38;23484:18;;94609:41:0::1;23177:331:1::0;94609:41:0::1;94661:27;94671:8;94681:6;94661:9;:27::i;:::-;94699:25;:13;9121:19:::0;;9139:1;9121:19;;;9032:127;87368:201;25394:13;:11;:13::i;:::-;87459:9:::1;87454:108;87478:11;:18;87474:1;:22;87454:108;;;87518:11;87535;87547:1;87535:14;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;87518:32;;::::1;::::0;::::1;::::0;;-1:-1:-1;87518:32:0;;;;;;;::::1;::::0;;-1:-1:-1;;;;;;87518:32:0::1;-1:-1:-1::0;;;;;87518:32:0;;::::1;::::0;;;::::1;::::0;;87498:3;::::1;::::0;::::1;:::i;:::-;;;;87454:108;;90474:124:::0;25394:13;:11;:13::i;:::-;90560:30;;::::1;::::0;:13:::1;::::0;:30:::1;::::0;::::1;::::0;::::1;:::i;26414:201::-:0;25394:13;:11;:13::i;:::-;-1:-1:-1;;;;;26503:22:0;::::1;26495:73;;;::::0;-1:-1:-1;;;26495:73:0;;14143:2:1;26495:73:0::1;::::0;::::1;14125:21:1::0;14182:2;14162:18;;;14155:30;14221:34;14201:18;;;14194:62;-1:-1:-1;;;14272:18:1;;;14265:36;14318:19;;26495:73:0::1;13941:402:1::0;26495:73:0::1;26579:28;26598:8;26579:18;:28::i;87252:108::-:0;25394:13;:11;:13::i;:::-;87324:11:::1;:28:::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;87324:28:0;;;;;::::1;::::0;;-1:-1:-1;;;;;;87324:28:0::1;-1:-1:-1::0;;;;;87324:28:0;;;::::1;::::0;;;::::1;::::0;;87252:108::o;96261:114::-;25394:13;:11;:13::i;:::-;96323:44:::1;::::0;-1:-1:-1;;;;;96323:21:0;::::1;::::0;96345::::1;96323:44:::0;::::1;;;::::0;::::1;::::0;;;96345:21;96323;:44;::::1;;;;;;;;;;;;;::::0;::::1;;;;9032:127:::0;9121:19;;9139:1;9121:19;;;9032:127::o;59423:305::-;59525:4;-1:-1:-1;;;;;;59562:40:0;;-1:-1:-1;;;59562:40:0;;:105;;-1:-1:-1;;;;;;;59619:48:0;;-1:-1:-1;;;59619:48:0;59562:105;:158;;;-1:-1:-1;;;;;;;;;;51194:40:0;;;59684:36;51085:157;25673:132;25581:6;;-1:-1:-1;;;;;25581:6:0;21484:10;25737:23;25729:68;;;;-1:-1:-1;;;25729:68:0;;21856:2:1;25729:68:0;;;21838:21:1;;;21875:18;;;21868:30;21934:34;21914:18;;;21907:62;21986:18;;25729:68:0;21654:356:1;24146:120:0;23155:16;:14;:16::i;:::-;24205:7:::1;:15:::0;;-1:-1:-1;;24205:15:0::1;::::0;;24236:22:::1;21484:10:::0;24245:12:::1;24236:22;::::0;-1:-1:-1;;;;;9536:32:1;;;9518:51;;9506:2;9491:18;24236:22:0::1;;;;;;;24146:120::o:0;69838:135::-;65121:4;65145:16;;;:7;:16;;;;;;-1:-1:-1;;;;;65145:16:0;69912:53;;;;-1:-1:-1;;;69912:53:0;;22217:2:1;69912:53:0;;;22199:21:1;22256:2;22236:18;;;22229:30;-1:-1:-1;;;22275:18:1;;;22268:54;22339:18;;69912:53:0;22015:348:1;69117:174:0;69192:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;69192:29:0;-1:-1:-1;;;;;69192:29:0;;;;;;;;:24;;69246:23;69192:24;69246:14;:23::i;:::-;-1:-1:-1;;;;;69237:46:0;;;;;;;;;;;69117:174;;:::o;29467:317::-;29582:6;29557:21;:31;;29549:73;;;;-1:-1:-1;;;29549:73:0;;17607:2:1;29549:73:0;;;17589:21:1;17646:2;17626:18;;;17619:30;17685:31;17665:18;;;17658:59;17734:18;;29549:73:0;17405:353:1;29549:73:0;29636:12;29654:9;-1:-1:-1;;;;;29654:14:0;29676:6;29654:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29635:52;;;29706:7;29698:78;;;;-1:-1:-1;;;29698:78:0;;17180:2:1;29698:78:0;;;17162:21:1;17219:2;17199:18;;;17192:30;17258:34;17238:18;;;17231:62;17329:28;17309:18;;;17302:56;17375:19;;29698:78:0;16978:422:1;65350:264:0;65443:4;65460:13;65476:23;65491:7;65476:14;:23::i;:::-;65460:39;;65529:5;-1:-1:-1;;;;;65518:16:0;:7;-1:-1:-1;;;;;65518:16:0;;:52;;;-1:-1:-1;;;;;;62453:25:0;;;62429:4;62453:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;65538:32;65518:87;;;;65598:7;-1:-1:-1;;;;;65574:31:0;:20;65586:7;65574:11;:20::i;:::-;-1:-1:-1;;;;;65574:31:0;;;65350:264;-1:-1:-1;;;;65350:264:0:o;68373:625::-;68532:4;-1:-1:-1;;;;;68505:31:0;:23;68520:7;68505:14;:23::i;:::-;-1:-1:-1;;;;;68505:31:0;;68497:81;;;;-1:-1:-1;;;68497:81:0;;15251:2:1;68497:81:0;;;15233:21:1;15290:2;15270:18;;;15263:30;15329:34;15309:18;;;15302:62;-1:-1:-1;;;15380:18:1;;;15373:35;15425:19;;68497:81:0;15049:401:1;68497:81:0;-1:-1:-1;;;;;68597:16:0;;68589:65;;;;-1:-1:-1;;;68589:65:0;;16421:2:1;68589:65:0;;;16403:21:1;16460:2;16440:18;;;16433:30;16499:34;16479:18;;;16472:62;-1:-1:-1;;;16550:18:1;;;16543:34;16594:19;;68589:65:0;16219:400:1;68589:65:0;68667:39;68688:4;68694:2;68698:7;68667:20;:39::i;:::-;68771:29;68788:1;68792:7;68771:8;:29::i;:::-;-1:-1:-1;;;;;68813:15:0;;;;;;:9;:15;;;;;:20;;68832:1;;68813:15;:20;;68832:1;;68813:20;:::i;:::-;;;;-1:-1:-1;;;;;;;68844:13:0;;;;;;:9;:13;;;;;:18;;68861:1;;68844:13;:18;;68861:1;;68844:18;:::i;:::-;;;;-1:-1:-1;;68873:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;68873:21:0;-1:-1:-1;;;;;68873:21:0;;;;;;;;;68912:27;;68873:16;;68912:27;;;;;;;61450:347;61380:417;;:::o;65956:110::-;66032:26;66042:2;66046:7;66032:26;;;;;;;;;;;;:9;:26::i;23887:118::-;22896:19;:17;:19::i;:::-;23947:7:::1;:14:::0;;-1:-1:-1;;23947:14:0::1;23957:4;23947:14;::::0;;23977:20:::1;23984:12;21484:10:::0;;21404:98;36240:211;36384:58;;;-1:-1:-1;;;;;9780:32:1;;36384:58:0;;;9762:51:1;9829:18;;;;9822:34;;;36384:58:0;;;;;;;;;;9735:18:1;;;;36384:58:0;;;;;;;;-1:-1:-1;;;;;36384:58:0;-1:-1:-1;;;36384:58:0;;;36357:86;;36377:5;;36357:19;:86::i;23450:108::-;23362:7;;;;23520:9;23512:38;;;;-1:-1:-1;;;23512:38:0;;19132:2:1;23512:38:0;;;19114:21:1;19171:2;19151:18;;;19144:30;-1:-1:-1;;;19190:18:1;;;19183:46;19246:18;;23512:38:0;18930:340:1;84005:392:0;84127:40;84146:10;84158:8;84127:18;:40::i;:::-;84119:49;;;;;;84206:15;84212:8;84206:5;:15::i;:::-;84299:90;;;;;;;;84319:15;84299:90;;84349:10;84299:90;;;;;;;84374:4;84299:90;;;;;;-1:-1:-1;84280:16:0;;;:6;:16;;;;;;;:109;;;;;;;;;;;;;-1:-1:-1;;;84280:109:0;-1:-1:-1;;;;;;84280:109:0;;;-1:-1:-1;;;;;84280:109:0;;;;;;;;;;;;;;84005:392::o;26775:191::-;26868:6;;;-1:-1:-1;;;;;26885:17:0;;;-1:-1:-1;;;;;;26885:17:0;;;;;;;26918:40;;26868:6;;;26885:17;26868:6;;26918:40;;26849:16;;26918:40;26838:128;26775:191;:::o;95021:366::-;95089:15;;95069:4;;-1:-1:-1;;;95089:15:0;;;;95086:58;;;-1:-1:-1;95128:4:0;;95021:366::o;95086:58::-;95154:16;95194:9;95189:162;95213:11;:18;95209:22;;95189:162;;;95275:10;-1:-1:-1;;;;;95257:28:0;:11;95269:1;95257:14;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;95257:14:0;:28;95253:87;;;95320:4;95306:18;;95253:87;95233:3;;;;:::i;:::-;;;;95189:162;;;-1:-1:-1;95368:11:0;95021:366;-1:-1:-1;95021:366:0:o;69434:315::-;69589:8;-1:-1:-1;;;;;69580:17:0;:5;-1:-1:-1;;;;;69580:17:0;;;69572:55;;;;-1:-1:-1;;;69572:55:0;;16826:2:1;69572:55:0;;;16808:21:1;16865:2;16845:18;;;16838:30;16904:27;16884:18;;;16877:55;16949:18;;69572:55:0;16624:349:1;69572:55:0;-1:-1:-1;;;;;69638:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;69638:46:0;;;;;;;;;;69700:41;;11442::1;;;69700::0;;11415:18:1;69700:41:0;;;;;;;69434:315;;;:::o;47329:248::-;47539:12;;-1:-1:-1;;;;;47519:16:0;;47475:7;47519:16;;;:7;:16;;;;;;47475:7;;47554:15;;47503:32;;:13;:32;:::i;:::-;47502:49;;;;:::i;:::-;:67;;;;:::i;64430:313::-;64586:28;64596:4;64602:2;64606:7;64586:9;:28::i;:::-;64633:47;64656:4;64662:2;64666:7;64675:4;64633:22;:47::i;:::-;64625:110;;;;-1:-1:-1;;;64625:110:0;;;;;;;:::i;84658:594::-;84771:16;;;;:6;:16;;;;;:29;;;-1:-1:-1;;;84771:29:0;;;;84763:66;;;;-1:-1:-1;;;84763:66:0;;12959:2:1;84763:66:0;;;12941:21:1;12998:2;12978:18;;;12971:30;13037:26;13017:18;;;13010:54;13081:18;;84763:66:0;12757:348:1;84763:66:0;84919:16;;;;:6;:16;;;;;:22;;;-1:-1:-1;;;;;84919:22:0;84945:10;84919:36;84897:120;;;;-1:-1:-1;;;84897:120:0;;21028:2:1;84897:120:0;;;21010:21:1;21067:2;21047:18;;;21040:30;21106:34;21086:18;;;21079:62;-1:-1:-1;;;21157:18:1;;;21150:32;21199:19;;84897:120:0;20826:398:1;84897:120:0;85081:18;85102:16;;;:6;:16;;;;;;;;85081:37;;;;;;;;;;;;;;;;-1:-1:-1;;;;;85081:37:0;;;;;;;;;-1:-1:-1;;;85081:37:0;;;;;;;;;;;;85136:16;;;;;;;85129:23;;;-1:-1:-1;;;;;;85129:23:0;;;;;85222:11;85212:32;;85109:8;85212:9;:32::i;90098:195::-;90192:8;;90158:13;;90192:8;;:16;;:8;:16;90184:67;;;;-1:-1:-1;;;90184:67:0;;22972:2:1;90184:67:0;;;22954:21:1;23011:2;22991:18;;;22984:30;23050:34;23030:18;;;23023:62;-1:-1:-1;;;23101:18:1;;;23094:36;23147:19;;90184:67:0;22770:402:1;90184:67:0;90269:16;90262:23;;;;;:::i;18658:723::-;18714:13;18935:10;18931:53;;-1:-1:-1;;18962:10:0;;;;;;;;;;;;-1:-1:-1;;;18962:10:0;;;;;18658:723::o;18931:53::-;19009:5;18994:12;19050:78;19057:9;;19050:78;;19083:8;;;;:::i;:::-;;-1:-1:-1;19106:10:0;;-1:-1:-1;19114:2:0;19106:10;;:::i;:::-;;;19050:78;;;19138:19;19170:6;19160:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19160:17:0;;19138:39;;19188:154;19195:10;;19188:154;;19222:11;19232:1;19222:11;;:::i;:::-;;-1:-1:-1;19291:10:0;19299:2;19291:5;:10;:::i;:::-;19278:24;;:2;:24;:::i;:::-;19265:39;;19248:6;19255;19248:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;19248:56:0;;;;;;;;-1:-1:-1;19319:11:0;19328:2;19319:11;;:::i;:::-;;;19188:154;;23635:108;23362:7;;;;23694:41;;;;-1:-1:-1;;;23694:41:0;;12263:2:1;23694:41:0;;;12245:21:1;12302:2;12282:18;;;12275:30;-1:-1:-1;;;12321:18:1;;;12314:50;12381:18;;23694:41:0;12061:344:1;75292:589:0;-1:-1:-1;;;;;75498:18:0;;75494:187;;75533:40;75565:7;76708:10;:17;;76681:24;;;;:15;:24;;;;;:44;;;76736:24;;;;;;;;;;;;76604:164;75533:40;75494:187;;;75603:2;-1:-1:-1;;;;;75595:10:0;:4;-1:-1:-1;;;;;75595:10:0;;75591:90;;75622:47;75655:4;75661:7;75622:32;:47::i;:::-;-1:-1:-1;;;;;75695:16:0;;75691:183;;75728:45;75765:7;75728:36;:45::i;75691:183::-;75801:4;-1:-1:-1;;;;;75795:10:0;:2;-1:-1:-1;;;;;75795:10:0;;75791:83;;75822:40;75850:2;75854:7;75822:27;:40::i;66293:319::-;66422:18;66428:2;66432:7;66422:5;:18::i;:::-;66473:53;66504:1;66508:2;66512:7;66521:4;66473:22;:53::i;:::-;66451:153;;;;-1:-1:-1;;;66451:153:0;;;;;;;:::i;39307:716::-;39731:23;39757:69;39785:4;39757:69;;;;;;;;;;;;;;;;;39765:5;-1:-1:-1;;;;;39757:27:0;;;:69;;;;;:::i;:::-;39841:17;;39731:95;;-1:-1:-1;39841:21:0;39837:179;;39938:10;39927:30;;;;;;;;;;;;:::i;:::-;39919:85;;;;-1:-1:-1;;;39919:85:0;;24898:2:1;39919:85:0;;;24880:21:1;24937:2;24917:18;;;24910:30;24976:34;24956:18;;;24949:62;-1:-1:-1;;;25027:18:1;;;25020:40;25077:19;;39919:85:0;24696:406:1;67616:420:0;67676:13;67692:23;67707:7;67692:14;:23::i;:::-;67676:39;;67728:48;67749:5;67764:1;67768:7;67728:20;:48::i;:::-;67817:29;67834:1;67838:7;67817:8;:29::i;:::-;-1:-1:-1;;;;;67859:16:0;;;;;;:9;:16;;;;;:21;;67879:1;;67859:16;:21;;67879:1;;67859:21;:::i;:::-;;;;-1:-1:-1;;67898:16:0;;;;:7;:16;;;;;;67891:23;;-1:-1:-1;;;;;;67891:23:0;;;67932:36;67906:7;;67898:16;-1:-1:-1;;;;;67932:36:0;;;;;67898:16;;67932:36;87783:25:::1;87700:116:::0;:::o;70537:853::-;70691:4;-1:-1:-1;;;;;70712:13:0;;28501:19;:23;70708:675;;70748:71;;-1:-1:-1;;;70748:71:0;;-1:-1:-1;;;;;70748:36:0;;;;;:71;;21484:10;;70799:4;;70805:7;;70814:4;;70748:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70748:71:0;;;;;;;;-1:-1:-1;;70748:71:0;;;;;;;;;;;;:::i;:::-;;;70744:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;70989:13:0;;70985:328;;71032:60;;-1:-1:-1;;;71032:60:0;;;;;;;:::i;70985:328::-;71263:6;71257:13;71248:6;71244:2;71240:15;71233:38;70744:584;-1:-1:-1;;;;;;70870:51:0;-1:-1:-1;;;70870:51:0;;-1:-1:-1;70863:58:0;;70708:675;-1:-1:-1;71367:4:0;70537:853;;;;;;:::o;77395:988::-;77661:22;77711:1;77686:22;77703:4;77686:16;:22::i;:::-;:26;;;;:::i;:::-;77723:18;77744:26;;;:17;:26;;;;;;77661:51;;-1:-1:-1;77877:28:0;;;77873:328;;-1:-1:-1;;;;;77944:18:0;;77922:19;77944:18;;;:12;:18;;;;;;;;:34;;;;;;;;;77995:30;;;;;;:44;;;78112:30;;:17;:30;;;;;:43;;;77873:328;-1:-1:-1;78297:26:0;;;;:17;:26;;;;;;;;78290:33;;;-1:-1:-1;;;;;78341:18:0;;;;;:12;:18;;;;;:34;;;;;;;78334:41;77395:988::o;78678:1079::-;78956:10;:17;78931:22;;78956:21;;78976:1;;78956:21;:::i;:::-;78988:18;79009:24;;;:15;:24;;;;;;79382:10;:26;;78931:46;;-1:-1:-1;79009:24:0;;78931:46;;79382:26;;;;;;:::i;:::-;;;;;;;;;79360:48;;79446:11;79421:10;79432;79421:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;79526:28;;;:15;:28;;;;;;;:41;;;79698:24;;;;;79691:31;79733:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;78749:1008;;;78678:1079;:::o;76182:221::-;76267:14;76284:20;76301:2;76284:16;:20::i;:::-;-1:-1:-1;;;;;76315:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;76360:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;76182:221:0:o;66948:439::-;-1:-1:-1;;;;;67028:16:0;;67020:61;;;;-1:-1:-1;;;67020:61:0;;20318:2:1;67020:61:0;;;20300:21:1;;;20337:18;;;20330:30;20396:34;20376:18;;;20369:62;20448:18;;67020:61:0;20116:356:1;67020:61:0;65121:4;65145:16;;;:7;:16;;;;;;-1:-1:-1;;;;;65145:16:0;:30;67092:58;;;;-1:-1:-1;;;67092:58:0;;15657:2:1;67092:58:0;;;15639:21:1;15696:2;15676:18;;;15669:30;15735;15715:18;;;15708:58;15783:18;;67092:58:0;15455:352:1;67092:58:0;67163:45;67192:1;67196:2;67200:7;67163:20;:45::i;:::-;-1:-1:-1;;;;;67221:13:0;;;;;;:9;:13;;;;;:18;;67238:1;;67221:13;:18;;67238:1;;67221:18;:::i;:::-;;;;-1:-1:-1;;67250:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;67250:21:0;-1:-1:-1;;;;;67250:21:0;;;;;;;;67289:33;;67250:16;;;67289:33;;67250:16;;67289:33;87783:25:::1;87700:116:::0;:::o;30951:229::-;31088:12;31120:52;31142:6;31150:4;31156:1;31159:12;31088;-1:-1:-1;;;;;28501:19:0;;;32358:60;;;;-1:-1:-1;;;32358:60:0;;23715:2:1;32358:60:0;;;23697:21:1;23754:2;23734:18;;;23727:30;23793:31;23773:18;;;23766:59;23842:18;;32358:60:0;23513:353:1;32358:60:0;32432:12;32446:23;32473:6;-1:-1:-1;;;;;32473:11:0;32492:5;32499:4;32473:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32431:73;;;;32522:51;32539:7;32548:10;32560:12;32522:16;:51::i;:::-;32515:58;32071:510;-1:-1:-1;;;;;;;32071:510:0:o;34757:762::-;34907:12;34936:7;34932:580;;;-1:-1:-1;34967:10:0;34960:17;;34932:580;35081:17;;:21;35077:424;;35329:10;35323:17;35390:15;35377:10;35373:2;35369:19;35362:44;35077:424;35472:12;35465:20;;-1:-1:-1;;;35465:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:406:1;78:5;112:18;104:6;101:30;98:56;;;134:18;;:::i;:::-;172:57;217:2;196:15;;-1:-1:-1;;192:29:1;223:4;188:40;172:57;:::i;:::-;163:66;;252:6;245:5;238:21;292:3;283:6;278:3;274:16;271:25;268:45;;;309:1;306;299:12;268:45;358:6;353:3;346:4;339:5;335:16;322:43;412:1;405:4;396:6;389:5;385:18;381:29;374:40;14:406;;;;;:::o;425:247::-;484:6;537:2;525:9;516:7;512:23;508:32;505:52;;;553:1;550;543:12;505:52;592:9;579:23;611:31;636:5;611:31;:::i;937:388::-;1005:6;1013;1066:2;1054:9;1045:7;1041:23;1037:32;1034:52;;;1082:1;1079;1072:12;1034:52;1121:9;1108:23;1140:31;1165:5;1140:31;:::i;:::-;1190:5;-1:-1:-1;1247:2:1;1232:18;;1219:32;1260:33;1219:32;1260:33;:::i;:::-;1312:7;1302:17;;;937:388;;;;;:::o;1330:456::-;1407:6;1415;1423;1476:2;1464:9;1455:7;1451:23;1447:32;1444:52;;;1492:1;1489;1482:12;1444:52;1531:9;1518:23;1550:31;1575:5;1550:31;:::i;:::-;1600:5;-1:-1:-1;1657:2:1;1642:18;;1629:32;1670:33;1629:32;1670:33;:::i;:::-;1330:456;;1722:7;;-1:-1:-1;;;1776:2:1;1761:18;;;;1748:32;;1330:456::o;1791:794::-;1886:6;1894;1902;1910;1963:3;1951:9;1942:7;1938:23;1934:33;1931:53;;;1980:1;1977;1970:12;1931:53;2019:9;2006:23;2038:31;2063:5;2038:31;:::i;:::-;2088:5;-1:-1:-1;2145:2:1;2130:18;;2117:32;2158:33;2117:32;2158:33;:::i;:::-;2210:7;-1:-1:-1;2264:2:1;2249:18;;2236:32;;-1:-1:-1;2319:2:1;2304:18;;2291:32;2346:18;2335:30;;2332:50;;;2378:1;2375;2368:12;2332:50;2401:22;;2454:4;2446:13;;2442:27;-1:-1:-1;2432:55:1;;2483:1;2480;2473:12;2432:55;2506:73;2571:7;2566:2;2553:16;2548:2;2544;2540:11;2506:73;:::i;:::-;2496:83;;;1791:794;;;;;;;:::o;2590:382::-;2655:6;2663;2716:2;2704:9;2695:7;2691:23;2687:32;2684:52;;;2732:1;2729;2722:12;2684:52;2771:9;2758:23;2790:31;2815:5;2790:31;:::i;:::-;2840:5;-1:-1:-1;2897:2:1;2882:18;;2869:32;2910:30;2869:32;2910:30;:::i;2977:315::-;3045:6;3053;3106:2;3094:9;3085:7;3081:23;3077:32;3074:52;;;3122:1;3119;3112:12;3074:52;3161:9;3148:23;3180:31;3205:5;3180:31;:::i;:::-;3230:5;3282:2;3267:18;;;;3254:32;;-1:-1:-1;;;2977:315:1:o;3297:1032::-;3381:6;3412:2;3455;3443:9;3434:7;3430:23;3426:32;3423:52;;;3471:1;3468;3461:12;3423:52;3511:9;3498:23;3540:18;3581:2;3573:6;3570:14;3567:34;;;3597:1;3594;3587:12;3567:34;3635:6;3624:9;3620:22;3610:32;;3680:7;3673:4;3669:2;3665:13;3661:27;3651:55;;3702:1;3699;3692:12;3651:55;3738:2;3725:16;3760:2;3756;3753:10;3750:36;;;3766:18;;:::i;:::-;3812:2;3809:1;3805:10;3795:20;;3835:28;3859:2;3855;3851:11;3835:28;:::i;:::-;3897:15;;;3928:12;;;;3960:11;;;3990;;;3986:20;;3983:33;-1:-1:-1;3980:53:1;;;4029:1;4026;4019:12;3980:53;4051:1;4042:10;;4061:238;4075:2;4072:1;4069:9;4061:238;;;4146:3;4133:17;4120:30;;4163:31;4188:5;4163:31;:::i;:::-;4207:18;;;4093:1;4086:9;;;;;4245:12;;;;4277;;4061:238;;;-1:-1:-1;4318:5:1;3297:1032;-1:-1:-1;;;;;;;;3297:1032:1:o;4334:241::-;4390:6;4443:2;4431:9;4422:7;4418:23;4414:32;4411:52;;;4459:1;4456;4449:12;4411:52;4498:9;4485:23;4517:28;4539:5;4517:28;:::i;4580:245::-;4647:6;4700:2;4688:9;4679:7;4675:23;4671:32;4668:52;;;4716:1;4713;4706:12;4668:52;4748:9;4742:16;4767:28;4789:5;4767:28;:::i;4830:245::-;4888:6;4941:2;4929:9;4920:7;4916:23;4912:32;4909:52;;;4957:1;4954;4947:12;4909:52;4996:9;4983:23;5015:30;5039:5;5015:30;:::i;5080:249::-;5149:6;5202:2;5190:9;5181:7;5177:23;5173:32;5170:52;;;5218:1;5215;5208:12;5170:52;5250:9;5244:16;5269:30;5293:5;5269:30;:::i;6007:450::-;6076:6;6129:2;6117:9;6108:7;6104:23;6100:32;6097:52;;;6145:1;6142;6135:12;6097:52;6185:9;6172:23;6218:18;6210:6;6207:30;6204:50;;;6250:1;6247;6240:12;6204:50;6273:22;;6326:4;6318:13;;6314:27;-1:-1:-1;6304:55:1;;6355:1;6352;6345:12;6304:55;6378:73;6443:7;6438:2;6425:16;6420:2;6416;6412:11;6378:73;:::i;6462:180::-;6521:6;6574:2;6562:9;6553:7;6549:23;6545:32;6542:52;;;6590:1;6587;6580:12;6542:52;-1:-1:-1;6613:23:1;;6462:180;-1:-1:-1;6462:180:1:o;6647:184::-;6717:6;6770:2;6758:9;6749:7;6745:23;6741:32;6738:52;;;6786:1;6783;6776:12;6738:52;-1:-1:-1;6809:16:1;;6647:184;-1:-1:-1;6647:184:1:o;6836:248::-;6904:6;6912;6965:2;6953:9;6944:7;6940:23;6936:32;6933:52;;;6981:1;6978;6971:12;6933:52;-1:-1:-1;;7004:23:1;;;7074:2;7059:18;;;7046:32;;-1:-1:-1;6836:248:1:o;7089:257::-;7130:3;7168:5;7162:12;7195:6;7190:3;7183:19;7211:63;7267:6;7260:4;7255:3;7251:14;7244:4;7237:5;7233:16;7211:63;:::i;:::-;7328:2;7307:15;-1:-1:-1;;7303:29:1;7294:39;;;;7335:4;7290:50;;7089:257;-1:-1:-1;;7089:257:1:o;7351:274::-;7480:3;7518:6;7512:13;7534:53;7580:6;7575:3;7568:4;7560:6;7556:17;7534:53;:::i;:::-;7603:16;;;;;7351:274;-1:-1:-1;;7351:274:1:o;7630:1527::-;7854:3;7892:6;7886:13;7918:4;7931:51;7975:6;7970:3;7965:2;7957:6;7953:15;7931:51;:::i;:::-;8045:13;;8004:16;;;;8067:55;8045:13;8004:16;8089:15;;;8067:55;:::i;:::-;8211:13;;8144:20;;;8184:1;;8271;8293:18;;;;8346;;;;8373:93;;8451:4;8441:8;8437:19;8425:31;;8373:93;8514:2;8504:8;8501:16;8481:18;8478:40;8475:167;;;-1:-1:-1;;;8541:33:1;;8597:4;8594:1;8587:15;8627:4;8548:3;8615:17;8475:167;8658:18;8685:110;;;;8809:1;8804:328;;;;8651:481;;8685:110;-1:-1:-1;;8720:24:1;;8706:39;;8765:20;;;;-1:-1:-1;8685:110:1;;8804:328;27499:1;27492:14;;;27536:4;27523:18;;8899:1;8913:169;8927:8;8924:1;8921:15;8913:169;;;9009:14;;8994:13;;;8987:37;9052:16;;;;8944:10;;8913:169;;;8917:3;;9113:8;9106:5;9102:20;9095:27;;8651:481;-1:-1:-1;9148:3:1;;7630:1527;-1:-1:-1;;;;;;;;;;;7630:1527:1:o;9867:488::-;-1:-1:-1;;;;;10136:15:1;;;10118:34;;10188:15;;10183:2;10168:18;;10161:43;10235:2;10220:18;;10213:34;;;10283:3;10278:2;10263:18;;10256:31;;;10061:4;;10304:45;;10329:19;;10321:6;10304:45;:::i;:::-;10296:53;9867:488;-1:-1:-1;;;;;;9867:488:1:o;10639:658::-;10810:2;10862:21;;;10932:13;;10835:18;;;10954:22;;;10781:4;;10810:2;11033:15;;;;11007:2;10992:18;;;10781:4;11076:195;11090:6;11087:1;11084:13;11076:195;;;11155:13;;-1:-1:-1;;;;;11151:39:1;11139:52;;11246:15;;;;11211:12;;;;11187:1;11105:9;11076:195;;;-1:-1:-1;11288:3:1;;10639:658;-1:-1:-1;;;;;;10639:658:1:o;11494:338::-;11636:2;11621:18;;11669:1;11658:13;;11648:144;;11714:10;11709:3;11705:20;11702:1;11695:31;11749:4;11746:1;11739:15;11777:4;11774:1;11767:15;11648:144;11801:25;;;11494:338;:::o;11837:219::-;11986:2;11975:9;11968:21;11949:4;12006:44;12046:2;12035:9;12031:18;12023:6;12006:44;:::i;13522:414::-;13724:2;13706:21;;;13763:2;13743:18;;;13736:30;13802:34;13797:2;13782:18;;13775:62;-1:-1:-1;;;13868:2:1;13853:18;;13846:48;13926:3;13911:19;;13522:414::o;15812:402::-;16014:2;15996:21;;;16053:2;16033:18;;;16026:30;16092:34;16087:2;16072:18;;16065:62;-1:-1:-1;;;16158:2:1;16143:18;;16136:36;16204:3;16189:19;;15812:402::o;18170:407::-;18372:2;18354:21;;;18411:2;18391:18;;;18384:30;18450:34;18445:2;18430:18;;18423:62;-1:-1:-1;;;18516:2:1;18501:18;;18494:41;18567:3;18552:19;;18170:407::o;25107:410::-;25309:2;25291:21;;;25348:2;25328:18;;;25321:30;25387:34;25382:2;25367:18;;25360:62;-1:-1:-1;;;25453:2:1;25438:18;;25431:44;25507:3;25492:19;;25107:410::o;27146:275::-;27217:2;27211:9;27282:2;27263:13;;-1:-1:-1;;27259:27:1;27247:40;;27317:18;27302:34;;27338:22;;;27299:62;27296:88;;;27364:18;;:::i;:::-;27400:2;27393:22;27146:275;;-1:-1:-1;27146:275:1:o;27552:128::-;27592:3;27623:1;27619:6;27616:1;27613:13;27610:39;;;27629:18;;:::i;:::-;-1:-1:-1;27665:9:1;;27552:128::o;27685:120::-;27725:1;27751;27741:35;;27756:18;;:::i;:::-;-1:-1:-1;27790:9:1;;27685:120::o;27810:168::-;27850:7;27916:1;27912;27908:6;27904:14;27901:1;27898:21;27893:1;27886:9;27879:17;27875:45;27872:71;;;27923:18;;:::i;:::-;-1:-1:-1;27963:9:1;;27810:168::o;27983:125::-;28023:4;28051:1;28048;28045:8;28042:34;;;28056:18;;:::i;:::-;-1:-1:-1;28093:9:1;;27983:125::o;28113:258::-;28185:1;28195:113;28209:6;28206:1;28203:13;28195:113;;;28285:11;;;28279:18;28266:11;;;28259:39;28231:2;28224:10;28195:113;;;28326:6;28323:1;28320:13;28317:48;;;-1:-1:-1;;28361:1:1;28343:16;;28336:27;28113:258::o;28376:380::-;28455:1;28451:12;;;;28498;;;28519:61;;28573:4;28565:6;28561:17;28551:27;;28519:61;28626:2;28618:6;28615:14;28595:18;28592:38;28589:161;;;28672:10;28667:3;28663:20;28660:1;28653:31;28707:4;28704:1;28697:15;28735:4;28732:1;28725:15;28761:135;28800:3;-1:-1:-1;;28821:17:1;;28818:43;;;28841:18;;:::i;:::-;-1:-1:-1;28888:1:1;28877:13;;28761:135::o;28901:112::-;28933:1;28959;28949:35;;28964:18;;:::i;:::-;-1:-1:-1;28998:9:1;;28901:112::o;29018:127::-;29079:10;29074:3;29070:20;29067:1;29060:31;29110:4;29107:1;29100:15;29134:4;29131:1;29124:15;29150:127;29211:10;29206:3;29202:20;29199:1;29192:31;29242:4;29239:1;29232:15;29266:4;29263:1;29256:15;29282:127;29343:10;29338:3;29334:20;29331:1;29324:31;29374:4;29371:1;29364:15;29398:4;29395:1;29388:15;29414:127;29475:10;29470:3;29466:20;29463:1;29456:31;29506:4;29503:1;29496:15;29530:4;29527:1;29520:15;29546:127;29607:10;29602:3;29598:20;29595:1;29588:31;29638:4;29635:1;29628:15;29662:4;29659:1;29652:15;29678:127;29739:10;29734:3;29730:20;29727:1;29720:31;29770:4;29767:1;29760:15;29794:4;29791:1;29784:15;29810:131;-1:-1:-1;;;;;29885:31:1;;29875:42;;29865:70;;29931:1;29928;29921:12;29946:118;30032:5;30025:13;30018:21;30011:5;30008:32;29998:60;;30054:1;30051;30044:12;30069:131;-1:-1:-1;;;;;;30143:32:1;;30133:43;;30123:71;;30190:1;30187;30180:12
Swarm Source
ipfs://0d380a95a3bbeb215fd1d3f99c8ade17fefddde215e0552306049d736a5f6e1b
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 24 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|---|---|---|---|---|
MATIC | Polygon (MATIC) | 100.00% | $1 | 0.02 | $0.020036 |
[ Download: CSV Export ]
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.