ERC-721
Overview
Max Total Supply
666 SLMBZ
Holders
189
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Balance
0 SLMBZLoading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
SlimeBallZ
Compiler Version
v0.8.15+commit.e14f2714
Contract Source Code (Solidity)
/** *Submitted for verification at ftmscan.com on 2022-07-21 */ // SPDX-License-Identifier: MIT // 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: contracts/LimitedSupply.sol pragma solidity ^0.8.0; /** LimitedSupply.sol is a slightly modified smart contract that act as token * tracker that limits the maximum token supply and increments token IDs on each new mint * based on WithLimitedSupply.sol from https://github.com/1001-digital/erc721-extensions/blob/main/contracts/WithLimitedSupply.sol. */ /// Original @author 1001.digital /// Modified by #NonBlokMovement abstract contract LimitedSupply { using Counters for Counters.Counter; // Keeps track of how many we have minted Counters.Counter private _tokenCount; /// @dev The maximum count of tokens this token tracker will hold. uint256 private _maxSupply; /// Instanciate the contract /// @param maxSupply_ how many tokens this collection should hold constructor (uint256 maxSupply_) { _maxSupply = maxSupply_; } /// @dev Get the max Supply /// @return the maximum token count function maxSupply() public view virtual returns (uint256) { return _maxSupply; } /// @dev Get the current token count /// @return the created token count function tokenCount() public view returns (uint256) { return _tokenCount.current(); } /// @dev Check whether tokens are still available /// @return the available token count function availableTokenCount() public view returns (uint256) { return maxSupply() - tokenCount(); } /// @dev Increment the token count and fetch the latest count /// @return the next token id function nextToken() internal virtual returns (uint256) { uint256 token = _tokenCount.current(); _tokenCount.increment(); return token; } /// @dev Check whether another token is still available modifier ensureAvailability() { require(availableTokenCount() > 0, "No more tokens available, find us on secondary marketplace."); _; } /// @param amount Check whether number of tokens are still available /// @dev Check whether tokens are still available modifier ensureAvailabilityFor(uint256 amount) { require(availableTokenCount() >= amount, "Requested number of tokens not available."); _; } } // File: contracts/PseudoRandom.sol pragma solidity ^0.8.0; /** PseudoRandom.sol is a slightly modified smart contract that randomly assign tokenIDs from a given set of tokens * based on RandomlyAssigned.sol from https://github.com/1001-digital/erc721-extensions/blob/main/contracts/RandomlyAssigned.sol. */ /// Original @author 1001.digital /// Modified by #NonBlokMovement abstract contract PseudoRandom is LimitedSupply { // Used for random index assignment mapping(uint256 => uint256) private tokenMatrix; // The initial token ID uint256 private startFrom; /// Instanciate the contract /// @param _maxSupply how many tokens this collection should hold /// @param _startFrom the tokenID with which to start counting constructor (uint256 _maxSupply, uint256 _startFrom) LimitedSupply(_maxSupply) { startFrom = _startFrom; } /// Get the next token ID /// @dev Randomly gets a new token ID and keeps track of the ones that are still available. /// @return the next token ID function nextToken() internal override ensureAvailability returns (uint256) { uint256 maxIndex = maxSupply() - tokenCount(); uint256 random = uint256(keccak256( abi.encodePacked( msg.sender, block.coinbase, block.difficulty, block.gaslimit, block.timestamp ) )) % maxIndex; uint256 value = 0; if (tokenMatrix[random] == 0) { // If this matrix position is empty, set the value to the generated random number. value = random; } else { // Otherwise, use the previously stored number from the matrix. value = tokenMatrix[random]; } // If the last available tokenID is still unused... if (tokenMatrix[maxIndex - 1] == 0) { // ...store that ID in the current matrix position. tokenMatrix[random] = maxIndex - 1; } else { // ...otherwise copy over the stored number to the current matrix position. tokenMatrix[random] = tokenMatrix[maxIndex - 1]; } // Increment counts super.nextToken(); return value + startFrom; } } // File: @openzeppelin/contracts/utils/math/SafeMath.sol // OpenZeppelin Contracts (last updated v4.6.0) (utils/math/SafeMath.sol) pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the subtraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File: @openzeppelin/contracts/security/ReentrancyGuard.sol // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // File: @openzeppelin/contracts/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/interfaces/IERC20.sol // OpenZeppelin Contracts v4.4.1 (interfaces/IERC20.sol) pragma solidity ^0.8.0; // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/utils/Address.sol // OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResult(success, returndata, errorMessage); } /** * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/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/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: contracts/SlimeBallZ.sol /* SlimeBallZ is a free-mint NFT project by Mazochist_LAF Contract based on the NFT smart contract template for collective collection by #NonBlokMovement */ /// @author: #NonBlokMovement /// Contract based on: /// [https://docs.openzeppelin.com/contracts/3.x/erc721](https://docs.openzeppelin.com/contracts/3.x/erc721) /** * #NonBlokMovement or any individuals and/or parties related directly or indirectly to it are not * responsible for any results as a result of the future use of the fork of this smart contract. */ // Track #NonBlokMovement : https://twitter.com/search?q=%23nonblokmovement&f=live pragma solidity ^0.8.11; contract SlimeBallZ is ERC721, Ownable, ReentrancyGuard, PseudoRandom { using Strings for uint256; using SafeMath for uint256; // VARIABLES // Team members' addresses // Mazochist_LAF, Francesca Sparkles address public francescaAddress = 0xFcF8Df5Fbc253057410059351f5f536aE422c9d4; address public mazochistLAFAddress = 0x205607846698d4b8464FF0f6aab4a9a64b15839e; // The baseURI of the collection string private collectionBaseURI = "https://gateway.pinata.cloud/ipfs/QmNMzzvyLp78qSfhU8jrfsLqY4crVLtbxmEydtL9KyWXDT/"; // Team members' shares uint256 public francescaAddressFee = 2000; uint256 public mazochistLAFAddressFee = 8000; // Maximum mint amount per wallet uint256 public constant maxNftsMintPerWallet = 5; // Maximum mint amount per tx uint256 public constant maxNftsMintPerTx = 1; // Primary sale price uint256 public constant publicSalePrice = 0 ether; // Royalty amount uint256 private _royaltyAmount; // bool for public sale state bool public isPublicSaleActive; // EVENTS // Emitted when fees and royalties is succesfully withdrawn event WithdrawFees( address indexed teamAddress, uint256 amount); // Emitted when stuck NFTs is successfully withdrawn event WithdrawStuckNfts( address indexed devAddress, address tokenAddress, uint256 tokenId); // FUNCTION MODIFIERS // Making sure that no wallets mints more than the allowed amount per tx modifier maxPerTx(uint256 amount) { require(amount > 0 && amount <= maxNftsMintPerTx, "Max Nfts to mint per tx is exceeded." ); _; } // Calculate whether the payment for minting is sufficient modifier isCorrectPayment(uint256 price, uint256 amount) { require( price * amount == msg.value, "Insufficient payment." ); _; } // Making sure that no wallets mints more than the allowed amount modifier maxNftsPerWallet(uint256 amount) { require( balanceOf(msg.sender) + amount <= maxNftsMintPerWallet, "Max Nfts to mint per wallet is exceeded." ); _; } // Several functions can only be called by the collection's team members modifier onlyTeam { require( msg.sender == francescaAddress || msg.sender == mazochistLAFAddress, "Caller must be the team members of this collection."); _; } // The current state of public sale modifier publicSaleActive() { require(isPublicSaleActive, "Public sale is not open."); _; } // STRUCT, ARRAYS OR ENUMS // To store the team members' addresses address[] private teamList; // ERC2981's' interface id bytes4 private constant _INTERFACE_ID_ERC2981 = 0x2a55205a; // Mapping the team's fees mapping(address => uint256) public teamFees; // Mapping all tokenURIs mapping(uint256 => string) private tokenURIMap; // CONSTRUCTOR // Initializes the contract by setting the 'teamList', 'teamFees', // 'maxSupply', 'startFrom', 'name', and 'symbol' to the collection. constructor( uint256 amount, uint256 startFrom, address[] memory _teamList, uint256[] memory _fees ) ERC721("SlimeBallZ", "SLMBZ") PseudoRandom(amount, startFrom){ require(_teamList.length == _fees.length, "Error: invalid data."); // 8% royalties _royaltyAmount = 800; } // RECEIVE FUNCTION /** This function is intended as a way to receive native FTM from royalties to this smart contract's address. * All incoming funds to this smart contract in native FTM * other than royalties will not be refunded. */ // To receive native FTM receive() external payable { // Received native FTM automatically splitted among team members based on Team member's shares splitFees(msg.value); } // EXTERNAL FUNCTIONS // View the current baseURI function getBaseURI() external view returns (string memory) { return collectionBaseURI; } // For the public to mint the NFTs function mint (uint256 amount) public payable nonReentrant isCorrectPayment(publicSalePrice, amount) publicSaleActive maxPerTx(amount) maxNftsPerWallet(amount) ensureAvailabilityFor(amount) { for (uint256 index = 0; index < amount; index++) { _safeMint(msg.sender, nextToken()); } // If it's not a free mint, then the FTM from the sale will automatically splitted among team members splitFees(msg.value); } // Royalty informations function royaltyInfo( uint256 _tokenId, uint256 _salePrice ) external view returns (address receiver, uint256 royaltyAmount) { return (address(this), ((_salePrice * _royaltyAmount) / 10000)); } // To set a new baseURI of the collection in case of errors in the metadata function setBaseURI(string memory collectionBaseURI_) external onlyOwner { collectionBaseURI = collectionBaseURI_; } // Toggle for public sale. function setIsPublicSaleActive(bool _isPublicSaleActive) external onlyOwner { isPublicSaleActive = _isPublicSaleActive; } // To set a new tokenURI to a specific tokenId in case of errors in a specific token's metadata function setTokenURI(uint256 tokenId, string memory tokenURI_) external onlyOwner { tokenURIMap[tokenId] = tokenURI_; } /** Even this functions is exists, please do not send any ERC721 tokens to * this smart contract as they will not be returned to the sender. * All the stuck ERC721 tokens will be stuck forever if this contract * ownership is transferred to the zero address. */ // Withdraw ERC721 tokens that wrongfully sent to this smart contract function withdrawNFT(address _tokenContract, uint256[] memory _id) external onlyOwner { IERC721 tokenContract = IERC721(_tokenContract); for (uint256 i = 0; i < _id.length; i++) { tokenContract.safeTransferFrom(address(this), owner(), _id[i]); emit WithdrawStuckNfts(msg.sender,_tokenContract,_id[i]); } } /** Any withdrawals using this function will be automatically * shared among the team members as this function is intended to be used * as a fair way to distribute royalties. * Please understand that all funds that were wrongfully sent to this * smart contract will not be refunded. * Team members of this collection can call this function in an permissionless way * even the contract ownership is transferred to the zero address. */ // Withdraw wFTM from royalties or other ERC20 tokens sent to this smart contract function withdrawTokens(address tokenContract) external onlyTeam { uint amount = IERC20(tokenContract).balanceOf(address(this)); require(amount > 0, "No Tokens."); // Shares based on the Team members' shares variable. IERC20(tokenContract).transfer(francescaAddress, amount * 2000 / 10000); IERC20(tokenContract).transfer(mazochistLAFAddress, amount * 8000 / 10000); } // PUBLIC FUNCTIONS // Interfaces function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721) returns (bool) { if (interfaceId == _INTERFACE_ID_ERC2981) { return true; } return super.supportsInterface(interfaceId); } // View individuals token's URI function tokenURI(uint256 tokenId) public view override returns (string memory) { string memory tokenURI_ = tokenURIMap[tokenId]; if (bytes(tokenURI_).length > 0) { return tokenURI_; } // The metadata must have .json file extension return string(abi.encodePacked(super.tokenURI(tokenId), ".json")); } /** Any withdrawals using this function will be automatically * shared among the team members as this function is intended to be used * as a fair way to distribute the sale proceeds from the primary sale. * Please understand that all funds in native FTM that were wrongfully * sent to this smart contract will also be withdrawn if this function * is called and will not be refunded. * Team members of this collection can call this function in an permisionless way * even the contract ownership is transferred to the zero address. */ // Team members withdraw their share of fees and royalties function withdraw() public onlyTeam { uint256 amount = teamFees[msg.sender]; require(amount > 0,"No Fees."); payable(msg.sender).transfer(amount); teamFees[msg.sender] = 0; emit WithdrawFees(msg.sender, amount); } // To view the total supply function totalSupply() public view returns (uint256) { return tokenCount(); } // INTERNAL FUNCTIONS // Splitting fees and royalties among team members function splitFees(uint256 sentAmount) internal { uint256 francescaAddressFeeAmount = sentAmount.mul(francescaAddressFee).div(10000); uint256 mazochistLAFAddressFeeAmount = sentAmount.mul(mazochistLAFAddressFee).div(10000); teamFees[francescaAddress] += francescaAddressFeeAmount; teamFees[mazochistLAFAddress] += mazochistLAFAddressFeeAmount; } // To set the baseURI of the collection function _baseURI() internal view virtual override returns (string memory) { return collectionBaseURI; } } /* Contract based on the NFT smart contract template for collective collection by: _ _ _ _ ____ _ _ __ __ _ _| || |_| \ | | | _ \| | | | | \/ | | | |_ __ _| \| | ___ _ __ | |_) | | ___ | | _| \ / | _____ _____ _ __ ___ ___ _ __ | |_ _| || |_| . ` |/ _ \| '_ \| _ <| |/ _ \| |/ / |\/| |/ _ \ \ / / _ \ '_ ` _ \ / _ \ '_ \| __| |_ __ _| |\ | (_) | | | | |_) | | (_) | <| | | | (_) \ V / __/ | | | | | __/ | | | |_ |_||_| |_| \_|\___/|_| |_|____/|_|\___/|_|\_\_| |_|\___/ \_/ \___|_| |_| |_|\___|_| |_|\__| */
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"startFrom","type":"uint256"},{"internalType":"address[]","name":"_teamList","type":"address[]"},{"internalType":"uint256[]","name":"_fees","type":"uint256[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"teamAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrawFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"devAddress","type":"address"},{"indexed":false,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"WithdrawStuckNfts","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"availableTokenCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"francescaAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"francescaAddressFee","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":"getBaseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isPublicSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxNftsMintPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxNftsMintPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mazochistLAFAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mazochistLAFAddressFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSalePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","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":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"collectionBaseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isPublicSaleActive","type":"bool"}],"name":"setIsPublicSaleActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"tokenURI_","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"teamFees","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenContract","type":"address"},{"internalType":"uint256[]","name":"_id","type":"uint256[]"}],"name":"withdrawNFT","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenContract","type":"address"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]
Contract Creation Code
600c80546001600160a01b031990811673fcf8df5fbc253057410059351f5f536ae422c9d417909155600d805490911673205607846698d4b8464ff0f6aab4a9a64b15839e179055610100604052605160808181529062002cd160a039600e906200006b908262000297565b506107d0600f55611f406010553480156200008557600080fd5b5060405162002d2238038062002d22833981016040819052620000a8916200042f565b8383816040518060400160405280600a81526020016929b634b6b2a130b6362d60b11b8152506040518060400160405280600581526020016429a626a12d60d91b8152508160009081620000fd919062000297565b5060016200010c828262000297565b50505062000129620001236200019c60201b60201c565b620001a0565b6001600755600955600b555080518251146200018b5760405162461bcd60e51b815260206004820152601460248201527f4572726f723a20696e76616c696420646174612e000000000000000000000000604482015260640160405180910390fd5b505061032060115550620005229050565b3390565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b634e487b7160e01b600052604160045260246000fd5b600181811c908216806200021d57607f821691505b6020821081036200023e57634e487b7160e01b600052602260045260246000fd5b50919050565b601f8211156200029257600081815260208120601f850160051c810160208610156200026d5750805b601f850160051c820191505b818110156200028e5782815560010162000279565b5050505b505050565b81516001600160401b03811115620002b357620002b3620001f2565b620002cb81620002c4845462000208565b8462000244565b602080601f831160018114620003035760008415620002ea5750858301515b600019600386901b1c1916600185901b1785556200028e565b600085815260208120601f198616915b82811015620003345788860151825594840194600190910190840162000313565b5085821015620003535787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b604051601f8201601f191681016001600160401b03811182821017156200038e576200038e620001f2565b604052919050565b60006001600160401b03821115620003b257620003b2620001f2565b5060051b60200190565b600082601f830112620003ce57600080fd5b81516020620003e7620003e18362000396565b62000363565b82815260059290921b840181019181810190868411156200040757600080fd5b8286015b848110156200042457805183529183019183016200040b565b509695505050505050565b600080600080608085870312156200044657600080fd5b845160208087015160408801519296509450906001600160401b03808211156200046f57600080fd5b818801915088601f8301126200048457600080fd5b815162000495620003e18262000396565b81815260059190911b8301840190848101908b831115620004b557600080fd5b938501935b82851015620004ec5784516001600160a01b0381168114620004dc5760008081fd5b82529385019390850190620004ba565b60608b015190975094505050808311156200050657600080fd5b50506200051687828801620003bc565b91505092959194509250565b61279f80620005326000396000f3fe6080604052600436106102295760003560e01c8063714c539811610123578063a22cb465116100ab578063d877976c1161006f578063d877976c14610645578063db9910361461065b578063e14ca35314610670578063e985e9c514610685578063f2fde38b146106ce57600080fd5b8063a22cb465146105ba578063b88d4fde146105da578063c07f5ac9146105fa578063c87b56dd14610610578063d5abeb011461063057600080fd5b806395d89b41116100f257806395d89b41146105485780639b6860c81461055d5780639bdedea5146105725780639f181b5e14610592578063a0712d68146105a757600080fd5b8063714c5398146104e0578063715018a6146104f55780637b3716261461050a5780638da5cb5b1461052a57600080fd5b806323b872dd116101b157806342f580cf1161017557806342f580cf1461044b57806349df728c1461046057806355f804b3146104805780636352211e146104a057806370a08231146104c057600080fd5b806323b872dd1461039757806328cad13d146103b75780632a55205a146103d75780633ccfd60b1461041657806342842e0e1461042b57600080fd5b8063162094c4116101f8578063162094c4146102ed57806318160ddd1461030d5780631e84c413146103305780631f873eb21461034a5780632326e9221461037757600080fd5b806301ffc9a71461023e57806306fdde0314610273578063081812fc14610295578063095ea7b3146102cd57600080fd5b3661023957610237346106ee565b005b600080fd5b34801561024a57600080fd5b5061025e610259366004611f15565b610798565b60405190151581526020015b60405180910390f35b34801561027f57600080fd5b506102886107c9565b60405161026a9190611f8a565b3480156102a157600080fd5b506102b56102b0366004611f9d565b61085b565b6040516001600160a01b03909116815260200161026a565b3480156102d957600080fd5b506102376102e8366004611fcd565b610882565b3480156102f957600080fd5b506102376103083660046120b6565b61099c565b34801561031957600080fd5b506103226109bc565b60405190815260200161026a565b34801561033c57600080fd5b5060125461025e9060ff1681565b34801561035657600080fd5b506103226103653660046120fd565b60146020526000908152604090205481565b34801561038357600080fd5b50600c546102b5906001600160a01b031681565b3480156103a357600080fd5b506102376103b2366004612118565b6109cb565b3480156103c357600080fd5b506102376103d2366004612162565b6109fc565b3480156103e357600080fd5b506103f76103f236600461217f565b610a17565b604080516001600160a01b03909316835260208301919091520161026a565b34801561042257600080fd5b50610237610a41565b34801561043757600080fd5b50610237610446366004612118565b610b45565b34801561045757600080fd5b50610322600581565b34801561046c57600080fd5b5061023761047b3660046120fd565b610b60565b34801561048c57600080fd5b5061023761049b3660046121a1565b610d86565b3480156104ac57600080fd5b506102b56104bb366004611f9d565b610d9e565b3480156104cc57600080fd5b506103226104db3660046120fd565b610dfe565b3480156104ec57600080fd5b50610288610e84565b34801561050157600080fd5b50610237610e93565b34801561051657600080fd5b50600d546102b5906001600160a01b031681565b34801561053657600080fd5b506006546001600160a01b03166102b5565b34801561055457600080fd5b50610288610ea7565b34801561056957600080fd5b50610322600081565b34801561057e57600080fd5b5061023761058d3660046121d6565b610eb6565b34801561059e57600080fd5b50610322610ff9565b6102376105b5366004611f9d565b611004565b3480156105c657600080fd5b506102376105d536600461228f565b61128f565b3480156105e657600080fd5b506102376105f53660046122c6565b61129a565b34801561060657600080fd5b5061032260105481565b34801561061c57600080fd5b5061028861062b366004611f9d565b6112cc565b34801561063c57600080fd5b50600954610322565b34801561065157600080fd5b50610322600f5481565b34801561066757600080fd5b50610322600181565b34801561067c57600080fd5b506103226113aa565b34801561069157600080fd5b5061025e6106a0366004612342565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b3480156106da57600080fd5b506102376106e93660046120fd565b6113c1565b600061071161271061070b600f548561143a90919063ffffffff16565b9061144d565b9050600061073061271061070b6010548661143a90919063ffffffff16565b600c546001600160a01b031660009081526014602052604081208054929350849290919061075f90849061238b565b9091555050600d546001600160a01b03166000908152601460205260408120805483929061078e90849061238b565b9091555050505050565b6000636ad56fd360e11b6001600160e01b03198316016107ba57506001919050565b6107c382611459565b92915050565b6060600080546107d8906123a3565b80601f0160208091040260200160405190810160405280929190818152602001828054610804906123a3565b80156108515780601f1061082657610100808354040283529160200191610851565b820191906000526020600020905b81548152906001019060200180831161083457829003601f168201915b5050505050905090565b6000610866826114a9565b506000908152600460205260409020546001600160a01b031690565b600061088d82610d9e565b9050806001600160a01b0316836001600160a01b0316036108ff5760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b60648201526084015b60405180910390fd5b336001600160a01b038216148061091b575061091b81336106a0565b61098d5760405162461bcd60e51b815260206004820152603e60248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f7420746f60448201527f6b656e206f776e6572206e6f7220617070726f76656420666f7220616c6c000060648201526084016108f6565b6109978383611508565b505050565b6109a4611576565b6000828152601560205260409020610997828261242b565b60006109c6610ff9565b905090565b6109d533826115d0565b6109f15760405162461bcd60e51b81526004016108f6906124eb565b61099783838361164f565b610a04611576565b6012805460ff1916911515919091179055565b6000803061271060115485610a2c9190612539565b610a36919061256e565b915091509250929050565b600c546001600160a01b0316331480610a645750600d546001600160a01b031633145b610a805760405162461bcd60e51b81526004016108f690612582565b3360009081526014602052604090205480610ac85760405162461bcd60e51b81526020600482015260086024820152672737902332b2b99760c11b60448201526064016108f6565b604051339082156108fc029083906000818181858888f19350505050158015610af5573d6000803e3d6000fd5b503360008181526014602052604080822091909155517f9bba815921f12cb7b1408e14b5ade745234397d39623ae5e7c82d693cb45815f90610b3a9084815260200190565b60405180910390a250565b6109978383836040518060200160405280600081525061129a565b600c546001600160a01b0316331480610b835750600d546001600160a01b031633145b610b9f5760405162461bcd60e51b81526004016108f690612582565b6040516370a0823160e01b81523060048201526000906001600160a01b038316906370a0823190602401602060405180830381865afa158015610be6573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c0a91906125d5565b905060008111610c495760405162461bcd60e51b815260206004820152600a6024820152692737902a37b5b2b7399760b11b60448201526064016108f6565b600c546001600160a01b038084169163a9059cbb9116612710610c6e856107d0612539565b610c78919061256e565b6040516001600160e01b031960e085901b1681526001600160a01b03909216600483015260248201526044016020604051808303816000875af1158015610cc3573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ce791906125ee565b50600d546001600160a01b038084169163a9059cbb9116612710610d0d85611f40612539565b610d17919061256e565b6040516001600160e01b031960e085901b1681526001600160a01b03909216600483015260248201526044016020604051808303816000875af1158015610d62573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061099791906125ee565b610d8e611576565b600e610d9a828261242b565b5050565b6000818152600260205260408120546001600160a01b0316806107c35760405162461bcd60e51b8152602060048201526018602482015277115490cdcc8c4e881a5b9d985b1a59081d1bdad95b88125160421b60448201526064016108f6565b60006001600160a01b038216610e685760405162461bcd60e51b815260206004820152602960248201527f4552433732313a2061646472657373207a65726f206973206e6f7420612076616044820152683634b21037bbb732b960b91b60648201526084016108f6565b506001600160a01b031660009081526003602052604090205490565b6060600e80546107d8906123a3565b610e9b611576565b610ea560006117eb565b565b6060600180546107d8906123a3565b610ebe611576565b8160005b8251811015610ff357816001600160a01b03166342842e0e30610eed6006546001600160a01b031690565b868581518110610eff57610eff61260b565b60209081029190910101516040516001600160e01b031960e086901b1681526001600160a01b0393841660048201529290911660248301526044820152606401600060405180830381600087803b158015610f5957600080fd5b505af1158015610f6d573d6000803e3d6000fd5b50505050336001600160a01b03167f08c573490d6e823ef0e3e26a4e2e37c982512e21c92fea5c29e54cd6ea24186e85858481518110610faf57610faf61260b565b6020026020010151604051610fd99291906001600160a01b03929092168252602082015260400190565b60405180910390a280610feb81612621565b915050610ec2565b50505050565b60006109c660085490565b6002600754036110565760405162461bcd60e51b815260206004820152601f60248201527f5265656e7472616e637947756172643a207265656e7472616e742063616c6c0060448201526064016108f6565b6002600755600081346110698284612539565b146110ae5760405162461bcd60e51b815260206004820152601560248201527424b739bab33334b1b4b2b73a103830bcb6b2b73a1760591b60448201526064016108f6565b60125460ff166111005760405162461bcd60e51b815260206004820152601860248201527f5075626c69632073616c65206973206e6f74206f70656e2e000000000000000060448201526064016108f6565b82600081118015611112575060018111155b61116a5760405162461bcd60e51b8152602060048201526024808201527f4d6178204e66747320746f206d696e74207065722074782069732065786365656044820152633232b21760e11b60648201526084016108f6565b8360058161117733610dfe565b611181919061238b565b11156111e05760405162461bcd60e51b815260206004820152602860248201527f4d6178204e66747320746f206d696e74207065722077616c6c657420697320656044820152673c31b2b2b232b21760c11b60648201526084016108f6565b84806111ea6113aa565b101561124a5760405162461bcd60e51b815260206004820152602960248201527f526571756573746564206e756d626572206f6620746f6b656e73206e6f7420616044820152683b30b4b630b136329760b91b60648201526084016108f6565b60005b86811015611278576112663361126161183d565b6119fc565b8061127081612621565b91505061124d565b50611282346106ee565b5050600160075550505050565b610d9a338383611a16565b6112a433836115d0565b6112c05760405162461bcd60e51b81526004016108f6906124eb565b610ff384848484611ae4565b6000818152601560205260408120805460609291906112ea906123a3565b80601f0160208091040260200160405190810160405280929190818152602001828054611316906123a3565b80156113635780601f1061133857610100808354040283529160200191611363565b820191906000526020600020905b81548152906001019060200180831161134657829003601f168201915b5050505050905060008151111561137a5792915050565b61138383611b17565b604051602001611393919061263a565b604051602081830303815290604052915050919050565b60006113b4610ff9565b6009546109c69190612663565b6113c9611576565b6001600160a01b03811661142e5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016108f6565b611437816117eb565b50565b60006114468284612539565b9392505050565b6000611446828461256e565b60006001600160e01b031982166380ac58cd60e01b148061148a57506001600160e01b03198216635b5e139f60e01b145b806107c357506301ffc9a760e01b6001600160e01b03198316146107c3565b6000818152600260205260409020546001600160a01b03166114375760405162461bcd60e51b8152602060048201526018602482015277115490cdcc8c4e881a5b9d985b1a59081d1bdad95b88125160421b60448201526064016108f6565b600081815260046020526040902080546001600160a01b0319166001600160a01b038416908117909155819061153d82610d9e565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b6006546001600160a01b03163314610ea55760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108f6565b6000806115dc83610d9e565b9050806001600160a01b0316846001600160a01b0316148061162357506001600160a01b0380821660009081526005602090815260408083209388168352929052205460ff165b806116475750836001600160a01b031661163c8461085b565b6001600160a01b0316145b949350505050565b826001600160a01b031661166282610d9e565b6001600160a01b0316146116c65760405162461bcd60e51b815260206004820152602560248201527f4552433732313a207472616e736665722066726f6d20696e636f72726563742060448201526437bbb732b960d91b60648201526084016108f6565b6001600160a01b0382166117285760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b60648201526084016108f6565b611733600082611508565b6001600160a01b038316600090815260036020526040812080546001929061175c908490612663565b90915550506001600160a01b038216600090815260036020526040812080546001929061178a90849061238b565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b0386811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b600680546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b6000806118486113aa565b116118bb5760405162461bcd60e51b815260206004820152603b60248201527f4e6f206d6f726520746f6b656e7320617661696c61626c652c2066696e64207560448201527f73206f6e207365636f6e64617279206d61726b6574706c6163652e000000000060648201526084016108f6565b60006118c5610ff9565b6009546118d29190612663565b6040516bffffffffffffffffffffffff1933606090811b8216602084015241901b166034820152446048820152456068820152426088820152909150600090829060a8016040516020818303038152906040528051906020012060001c611939919061267a565b6000818152600a602052604081205491925090810361195957508061196a565b506000818152600a60205260409020545b600a6000611979600186612663565b8152602001908152602001600020546000036119ae5761199a600184612663565b6000838152600a60205260409020556119de565b600a60006119bd600186612663565b81526020808201929092526040908101600090812054858252600a90935220555b6119e6611b67565b50600b546119f4908261238b565b935050505090565b610d9a828260405180602001604052806000815250611b88565b816001600160a01b0316836001600160a01b031603611a775760405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c65720000000000000060448201526064016108f6565b6001600160a01b03838116600081815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b611aef84848461164f565b611afb84848484611bbb565b610ff35760405162461bcd60e51b81526004016108f69061268e565b6060611b22826114a9565b6000611b2c610e84565b90506000815111611b4c5760405180602001604052806000815250611446565b80611b5684611cbc565b6040516020016113939291906126e0565b600080611b7360085490565b9050611b83600880546001019055565b919050565b611b928383611dbd565b611b9f6000848484611bbb565b6109975760405162461bcd60e51b81526004016108f69061268e565b60006001600160a01b0384163b15611cb157604051630a85bd0160e11b81526001600160a01b0385169063150b7a0290611bff90339089908890889060040161270f565b6020604051808303816000875af1925050508015611c3a575060408051601f3d908101601f19168201909252611c379181019061274c565b60015b611c97573d808015611c68576040519150601f19603f3d011682016040523d82523d6000602084013e611c6d565b606091505b508051600003611c8f5760405162461bcd60e51b81526004016108f69061268e565b805181602001fd5b6001600160e01b031916630a85bd0160e11b149050611647565b506001949350505050565b606081600003611ce35750506040805180820190915260018152600360fc1b602082015290565b8160005b8115611d0d5780611cf781612621565b9150611d069050600a8361256e565b9150611ce7565b60008167ffffffffffffffff811115611d2857611d28611ff7565b6040519080825280601f01601f191660200182016040528015611d52576020820181803683370190505b5090505b841561164757611d67600183612663565b9150611d74600a8661267a565b611d7f90603061238b565b60f81b818381518110611d9457611d9461260b565b60200101906001600160f81b031916908160001a905350611db6600a8661256e565b9450611d56565b6001600160a01b038216611e135760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f206164647265737360448201526064016108f6565b6000818152600260205260409020546001600160a01b031615611e785760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e7465640000000060448201526064016108f6565b6001600160a01b0382166000908152600360205260408120805460019290611ea190849061238b565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b03861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b6001600160e01b03198116811461143757600080fd5b600060208284031215611f2757600080fd5b813561144681611eff565b60005b83811015611f4d578181015183820152602001611f35565b83811115610ff35750506000910152565b60008151808452611f76816020860160208601611f32565b601f01601f19169290920160200192915050565b6020815260006114466020830184611f5e565b600060208284031215611faf57600080fd5b5035919050565b80356001600160a01b0381168114611b8357600080fd5b60008060408385031215611fe057600080fd5b611fe983611fb6565b946020939093013593505050565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff8111828210171561203657612036611ff7565b604052919050565b600067ffffffffffffffff83111561205857612058611ff7565b61206b601f8401601f191660200161200d565b905082815283838301111561207f57600080fd5b828260208301376000602084830101529392505050565b600082601f8301126120a757600080fd5b6114468383356020850161203e565b600080604083850312156120c957600080fd5b82359150602083013567ffffffffffffffff8111156120e757600080fd5b6120f385828601612096565b9150509250929050565b60006020828403121561210f57600080fd5b61144682611fb6565b60008060006060848603121561212d57600080fd5b61213684611fb6565b925061214460208501611fb6565b9150604084013590509250925092565b801515811461143757600080fd5b60006020828403121561217457600080fd5b813561144681612154565b6000806040838503121561219257600080fd5b50508035926020909101359150565b6000602082840312156121b357600080fd5b813567ffffffffffffffff8111156121ca57600080fd5b61164784828501612096565b600080604083850312156121e957600080fd5b6121f283611fb6565b915060208084013567ffffffffffffffff8082111561221057600080fd5b818601915086601f83011261222457600080fd5b81358181111561223657612236611ff7565b8060051b915061224784830161200d565b818152918301840191848101908984111561226157600080fd5b938501935b8385101561227f57843582529385019390850190612266565b8096505050505050509250929050565b600080604083850312156122a257600080fd5b6122ab83611fb6565b915060208301356122bb81612154565b809150509250929050565b600080600080608085870312156122dc57600080fd5b6122e585611fb6565b93506122f360208601611fb6565b925060408501359150606085013567ffffffffffffffff81111561231657600080fd5b8501601f8101871361232757600080fd5b6123368782356020840161203e565b91505092959194509250565b6000806040838503121561235557600080fd5b61235e83611fb6565b915061236c60208401611fb6565b90509250929050565b634e487b7160e01b600052601160045260246000fd5b6000821982111561239e5761239e612375565b500190565b600181811c908216806123b757607f821691505b6020821081036123d757634e487b7160e01b600052602260045260246000fd5b50919050565b601f82111561099757600081815260208120601f850160051c810160208610156124045750805b601f850160051c820191505b8181101561242357828155600101612410565b505050505050565b815167ffffffffffffffff81111561244557612445611ff7565b6124598161245384546123a3565b846123dd565b602080601f83116001811461248e57600084156124765750858301515b600019600386901b1c1916600185901b178555612423565b600085815260208120601f198616915b828110156124bd5788860151825594840194600190910190840161249e565b50858210156124db5787850151600019600388901b60f8161c191681555b5050505050600190811b01905550565b6020808252602e908201527f4552433732313a2063616c6c6572206973206e6f7420746f6b656e206f776e6560408201526d1c881b9bdc88185c1c1c9bdd995960921b606082015260800190565b600081600019048311821515161561255357612553612375565b500290565b634e487b7160e01b600052601260045260246000fd5b60008261257d5761257d612558565b500490565b60208082526033908201527f43616c6c6572206d75737420626520746865207465616d206d656d626572732060408201527237b3103a3434b99031b7b63632b1ba34b7b71760691b606082015260800190565b6000602082840312156125e757600080fd5b5051919050565b60006020828403121561260057600080fd5b815161144681612154565b634e487b7160e01b600052603260045260246000fd5b60006001820161263357612633612375565b5060010190565b6000825161264c818460208701611f32565b64173539b7b760d91b920191825250600501919050565b60008282101561267557612675612375565b500390565b60008261268957612689612558565b500690565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b600083516126f2818460208801611f32565b835190830190612706818360208801611f32565b01949350505050565b6001600160a01b038581168252841660208201526040810183905260806060820181905260009061274290830184611f5e565b9695505050505050565b60006020828403121561275e57600080fd5b815161144681611eff56fea264697066735822122086496cd0972a08f2330915f6b9bb19000c74757e3a457f47059c0e25494f8a6d64736f6c634300080f003368747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066732f516d4e4d7a7a76794c7037387153666855386a7266734c7159346372564c7462786d457964744c394b79575844542f000000000000000000000000000000000000000000000000000000000000029a0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000fcf8df5fbc253057410059351f5f536ae422c9d4000000000000000000000000205607846698d4b8464ff0f6aab4a9a64b15839e000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000007d00000000000000000000000000000000000000000000000000000000000001f40
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000000000000000000000000000000000000000029a0000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000002000000000000000000000000fcf8df5fbc253057410059351f5f536ae422c9d4000000000000000000000000205607846698d4b8464ff0f6aab4a9a64b15839e000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000007d00000000000000000000000000000000000000000000000000000000000001f40
-----Decoded View---------------
Arg [0] : amount (uint256): 666
Arg [1] : startFrom (uint256): 1
Arg [2] : _teamList (address[]): 0xFcF8Df5Fbc253057410059351f5f536aE422c9d4,0x205607846698d4b8464FF0f6aab4a9a64b15839e
Arg [3] : _fees (uint256[]): 2000,8000
-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 000000000000000000000000000000000000000000000000000000000000029a
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [3] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [5] : 000000000000000000000000fcf8df5fbc253057410059351f5f536ae422c9d4
Arg [6] : 000000000000000000000000205607846698d4b8464ff0f6aab4a9a64b15839e
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [8] : 00000000000000000000000000000000000000000000000000000000000007d0
Arg [9] : 0000000000000000000000000000000000000000000000000000000000001f40
Deployed Bytecode Sourcemap
57580:10134:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61741:20;61751:9;61741;:20::i;:::-;57580:10134;;;;;65272:304;;;;;;;;;;-1:-1:-1;65272:304:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;65272:304:0;;;;;;;;44634:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;46147:171::-;;;;;;;;;;-1:-1:-1;46147:171:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;46147:171:0;1528:203:1;45664:417:0;;;;;;;;;;-1:-1:-1;45664:417:0;;;;;:::i;:::-;;:::i;63335:156::-;;;;;;;;;;-1:-1:-1;63335:156:0;;;;;:::i;:::-;;:::i;66959:91::-;;;;;;;;;;;;;:::i;:::-;;;3765:25:1;;;3753:2;3738:18;66959:91:0;3619:177:1;58658:30:0;;;;;;;;;;-1:-1:-1;58658:30:0;;;;;;;;60632:43;;;;;;;;;;-1:-1:-1;60632:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;57822:76;;;;;;;;;;-1:-1:-1;57822:76:0;;;;-1:-1:-1;;;;;57822:76:0;;;46847:336;;;;;;;;;;-1:-1:-1;46847:336:0;;;;;:::i;:::-;;:::i;63068:158::-;;;;;;;;;;-1:-1:-1;63068:158:0;;;;;:::i;:::-;;:::i;62574:231::-;;;;;;;;;;-1:-1:-1;62574:231:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;5139:32:1;;;5121:51;;5203:2;5188:18;;5181:34;;;;5094:18;62574:231:0;4947:274:1;66655:263:0;;;;;;;;;;;;;:::i;47254:185::-;;;;;;;;;;-1:-1:-1;47254:185:0;;;;;:::i;:::-;;:::i;58329:48::-;;;;;;;;;;;;58376:1;58329:48;;64795:420;;;;;;;;;;-1:-1:-1;64795:420:0;;;;;:::i;:::-;;:::i;62894:130::-;;;;;;;;;;-1:-1:-1;62894:130:0;;;;;:::i;:::-;;:::i;44345:222::-;;;;;;;;;;-1:-1:-1;44345:222:0;;;;;:::i;:::-;;:::i;44076:207::-;;;;;;;;;;-1:-1:-1;44076:207:0;;;;;:::i;:::-;;:::i;61839:103::-;;;;;;;;;;;;;:::i;24257:::-;;;;;;;;;;;;;:::i;57905:79::-;;;;;;;;;;-1:-1:-1;57905:79:0;;;;-1:-1:-1;;;;;57905:79:0;;;23609:87;;;;;;;;;;-1:-1:-1;23682:6:0;;-1:-1:-1;;;;;23682:6:0;23609:87;;44803:104;;;;;;;;;;;;;:::i;58503:49::-;;;;;;;;;;;;58545:7;58503:49;;63863:363;;;;;;;;;;-1:-1:-1;63863:363:0;;;;;:::i;:::-;;:::i;2673:99::-;;;;;;;;;;;;;:::i;61990:545::-;;;;;;:::i;:::-;;:::i;46390:155::-;;;;;;;;;;-1:-1:-1;46390:155:0;;;;;:::i;:::-;;:::i;47510:323::-;;;;;;;;;;-1:-1:-1;47510:323:0;;;;;:::i;:::-;;:::i;58233:44::-;;;;;;;;;;;;;;;;65622:383;;;;;;;;;;-1:-1:-1;65622:383:0;;;;;:::i;:::-;;:::i;2487:95::-;;;;;;;;;;-1:-1:-1;2564:10:0;;2487:95;;58185:41;;;;;;;;;;;;;;;;58419:44;;;;;;;;;;;;58462:1;58419:44;;2878:113;;;;;;;;;;;;;:::i;46616:164::-;;;;;;;;;;-1:-1:-1;46616:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;46737:25:0;;;46713:4;46737:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;46616:164;24515:201;;;;;;;;;;-1:-1:-1;24515:201:0;;;;;:::i;:::-;;:::i;67143:397::-;67204:33;67240:46;67280:5;67240:35;67255:19;;67240:10;:14;;:35;;;;:::i;:::-;:39;;:46::i;:::-;67204:82;;67297:36;67336:49;67379:5;67336:38;67351:22;;67336:10;:14;;:38;;;;:::i;:49::-;67414:16;;-1:-1:-1;;;;;67414:16:0;67405:26;;;;:8;:26;;;;;:55;;67297:88;;-1:-1:-1;67435:25:0;;67405:26;;;:55;;67435:25;;67405:55;:::i;:::-;;;;-1:-1:-1;;67480:19:0;;-1:-1:-1;;;;;67480:19:0;67471:29;;;;:8;:29;;;;;:61;;67504:28;;67471:29;:61;;67504:28;;67471:61;:::i;:::-;;;;-1:-1:-1;;;;;67143:397:0:o;65272:304::-;65410:4;-1:-1:-1;;;;;;;;;65435:36:0;;;65431:84;;-1:-1:-1;65495:4:0;;65272:304;-1:-1:-1;65272:304:0:o;65431:84::-;65532:36;65556:11;65532:23;:36::i;:::-;65525:43;65272:304;-1:-1:-1;;65272:304:0:o;44634:100::-;44688:13;44721:5;44714:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44634:100;:::o;46147:171::-;46223:7;46243:23;46258:7;46243:14;:23::i;:::-;-1:-1:-1;46286:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;46286:24:0;;46147:171::o;45664:417::-;45745:13;45761:23;45776:7;45761:14;:23::i;:::-;45745:39;;45809:5;-1:-1:-1;;;;;45803:11:0;:2;-1:-1:-1;;;;;45803:11:0;;45795:57;;;;-1:-1:-1;;;45795:57:0;;8687:2:1;45795:57:0;;;8669:21:1;8726:2;8706:18;;;8699:30;8765:34;8745:18;;;8738:62;-1:-1:-1;;;8816:18:1;;;8809:31;8857:19;;45795:57:0;;;;;;;;;22240:10;-1:-1:-1;;;;;45887:21:0;;;;:62;;-1:-1:-1;45912:37:0;45929:5;22240:10;46616:164;:::i;45912:37::-;45865:174;;;;-1:-1:-1;;;45865:174:0;;9089:2:1;45865:174:0;;;9071:21:1;9128:2;9108:18;;;9101:30;9167:34;9147:18;;;9140:62;9238:32;9218:18;;;9211:60;9288:19;;45865:174:0;8887:426:1;45865:174:0;46052:21;46061:2;46065:7;46052:8;:21::i;:::-;45734:347;45664:417;;:::o;63335:156::-;23495:13;:11;:13::i;:::-;63451:20:::1;::::0;;;:11:::1;:20;::::0;;;;:32:::1;63474:9:::0;63451:20;:32:::1;:::i;66959:91::-:0;67003:7;67030:12;:10;:12::i;:::-;67023:19;;66959:91;:::o;46847:336::-;47042:41;22240:10;47075:7;47042:18;:41::i;:::-;47034:100;;;;-1:-1:-1;;;47034:100:0;;;;;;;:::i;:::-;47147:28;47157:4;47163:2;47167:7;47147:9;:28::i;63068:158::-;23495:13;:11;:13::i;:::-;63178:18:::1;:40:::0;;-1:-1:-1;;63178:40:0::1;::::0;::::1;;::::0;;;::::1;::::0;;63068:158::o;62574:231::-;62682:16;62700:21;62750:4;62790:5;62772:14;;62759:10;:27;;;;:::i;:::-;62758:37;;;;:::i;:::-;62734:63;;;;62574:231;;;;;:::o;66655:263::-;60059:16;;-1:-1:-1;;;;;60059:16:0;60045:10;:30;;:81;;-1:-1:-1;60107:19:0;;-1:-1:-1;;;;;60107:19:0;60093:10;:33;60045:81;60023:173;;;;-1:-1:-1;;;60023:173:0;;;;;;;:::i;:::-;66728:10:::1;66702:14;66719:20:::0;;;:8:::1;:20;::::0;;;;;66758:10;66750:30:::1;;;::::0;-1:-1:-1;;;66750:30:0;;12989:2:1;66750:30:0::1;::::0;::::1;12971:21:1::0;13028:1;13008:18;;;13001:29;-1:-1:-1;;;13046:18:1;;;13039:38;13094:18;;66750:30:0::1;12787:331:1::0;66750:30:0::1;66791:36;::::0;66799:10:::1;::::0;66791:36;::::1;;;::::0;66820:6;;66791:36:::1;::::0;;;66820:6;66799:10;66791:36;::::1;;;;;;;;;;;;;::::0;::::1;;;;;-1:-1:-1::0;66847:10:0::1;66861:1;66838:20:::0;;;:8:::1;:20;::::0;;;;;:24;;;;66878:32;::::1;::::0;::::1;::::0;66903:6;3765:25:1;;3753:2;3738:18;;3619:177;66878:32:0::1;;;;;;;;66691:227;66655:263::o:0;47254:185::-;47392:39;47409:4;47415:2;47419:7;47392:39;;;;;;;;;;;;:16;:39::i;64795:420::-;60059:16;;-1:-1:-1;;;;;60059:16:0;60045:10;:30;;:81;;-1:-1:-1;60107:19:0;;-1:-1:-1;;;;;60107:19:0;60093:10;:33;60045:81;60023:173;;;;-1:-1:-1;;;60023:173:0;;;;;;;:::i;:::-;64885:46:::1;::::0;-1:-1:-1;;;64885:46:0;;64925:4:::1;64885:46;::::0;::::1;1674:51:1::0;64871:11:0::1;::::0;-1:-1:-1;;;;;64885:31:0;::::1;::::0;::::1;::::0;1647:18:1;;64885:46:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64871:60;;64959:1;64950:6;:10;64942:33;;;::::0;-1:-1:-1;;;64942:33:0;;13514:2:1;64942:33:0::1;::::0;::::1;13496:21:1::0;13553:2;13533:18;;;13526:30;-1:-1:-1;;;13572:18:1;;;13565:40;13622:18;;64942:33:0::1;13312:334:1::0;64942:33:0::1;65082:16;::::0;-1:-1:-1;;;;;65051:30:0;;::::1;::::0;::::1;::::0;65082:16:::1;65116:5;65100:13;:6:::0;65109:4:::1;65100:13;:::i;:::-;:21;;;;:::i;:::-;65051:71;::::0;-1:-1:-1;;;;;;65051:71:0::1;::::0;;;;;;-1:-1:-1;;;;;5139:32:1;;;65051:71:0::1;::::0;::::1;5121:51:1::0;5188:18;;;5181:34;5094:18;;65051:71:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;65164:19:0::1;::::0;-1:-1:-1;;;;;65133:30:0;;::::1;::::0;::::1;::::0;65164:19:::1;65201:5;65185:13;:6:::0;65194:4:::1;65185:13;:::i;:::-;:21;;;;:::i;:::-;65133:74;::::0;-1:-1:-1;;;;;;65133:74:0::1;::::0;;;;;;-1:-1:-1;;;;;5139:32:1;;;65133:74:0::1;::::0;::::1;5121:51:1::0;5188:18;;;5181:34;5094:18;;65133:74:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;62894:130::-:0;23495:13;:11;:13::i;:::-;62978:17:::1;:38;62998:18:::0;62978:17;:38:::1;:::i;:::-;;62894:130:::0;:::o;44345:222::-;44417:7;44453:16;;;:7;:16;;;;;;-1:-1:-1;;;;;44453:16:0;;44480:56;;;;-1:-1:-1;;;44480:56:0;;14103:2:1;44480:56:0;;;14085:21:1;14142:2;14122:18;;;14115:30;-1:-1:-1;;;14161:18:1;;;14154:54;14225:18;;44480:56:0;13901:348:1;44076:207:0;44148:7;-1:-1:-1;;;;;44176:19:0;;44168:73;;;;-1:-1:-1;;;44168:73:0;;14456:2:1;44168:73:0;;;14438:21:1;14495:2;14475:18;;;14468:30;14534:34;14514:18;;;14507:62;-1:-1:-1;;;14585:18:1;;;14578:39;14634:19;;44168:73:0;14254:405:1;44168:73:0;-1:-1:-1;;;;;;44259:16:0;;;;;:9;:16;;;;;;;44076:207::o;61839:103::-;61884:13;61917:17;61910:24;;;;;:::i;24257:103::-;23495:13;:11;:13::i;:::-;24322:30:::1;24349:1;24322:18;:30::i;:::-;24257:103::o:0;44803:104::-;44859:13;44892:7;44885:14;;;;;:::i;63863:363::-;23495:13;:11;:13::i;:::-;63992:14;63960:21:::1;64018:201;64042:3;:10;64038:1;:14;64018:201;;;64074:13;-1:-1:-1::0;;;;;64074:30:0::1;;64113:4;64120:7;23682:6:::0;;-1:-1:-1;;;;;23682:6:0;;23609:87;64120:7:::1;64129:3;64133:1;64129:6;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;64074:62:::1;::::0;-1:-1:-1;;;;;;64074:62:0::1;::::0;;;;;;-1:-1:-1;;;;;15054:15:1;;;64074:62:0::1;::::0;::::1;15036:34:1::0;15106:15;;;;15086:18;;;15079:43;15138:18;;;15131:34;14971:18;;64074:62:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;64174:10;-1:-1:-1::0;;;;;64156:51:0::1;;64185:14;64200:3;64204:1;64200:6;;;;;;;;:::i;:::-;;;;;;;64156:51;;;;;;-1:-1:-1::0;;;;;5139:32:1;;;;5121:51;;5203:2;5188:18;;5181:34;5109:2;5094:18;;4947:274;64156:51:0::1;;;;;;;;64054:3:::0;::::1;::::0;::::1;:::i;:::-;;;;64018:201;;;;63949:277;63863:363:::0;;:::o;2673:99::-;2716:7;2743:21;:11;995:14;;903:114;61990:545;15009:1;15607:7;;:19;15599:63;;;;-1:-1:-1;;;15599:63:0;;15518:2:1;15599:63:0;;;15500:21:1;15557:2;15537:18;;;15530:30;15596:33;15576:18;;;15569:61;15647:18;;15599:63:0;15316:355:1;15599:63:0;15009:1;15740:7;:18;58545:7:::1;62119:6:::0;59525:9:::1;59507:14;62119:6:::0;58545:7;59507:14:::1;:::i;:::-;:27;59485:102;;;::::0;-1:-1:-1;;;59485:102:0;;15878:2:1;59485:102:0::1;::::0;::::1;15860:21:1::0;15917:2;15897:18;;;15890:30;-1:-1:-1;;;15936:18:1;;;15929:51;15997:18;;59485:102:0::1;15676:345:1::0;59485:102:0::1;60312:18:::2;::::0;::::2;;60304:55;;;::::0;-1:-1:-1;;;60304:55:0;;16228:2:1;60304:55:0::2;::::0;::::2;16210:21:1::0;16267:2;16247:18;;;16240:30;16306:26;16286:18;;;16279:54;16350:18;;60304:55:0::2;16026:348:1::0;60304:55:0::2;62171:6:::3;59226:1;59217:6;:10;:40;;;;;58462:1;59231:6;:26;;59217:40;59209:116;;;::::0;-1:-1:-1;;;59209:116:0;;16581:2:1;59209:116:0::3;::::0;::::3;16563:21:1::0;16620:2;16600:18;;;16593:30;16659:34;16639:18;;;16632:62;-1:-1:-1;;;16710:18:1;;;16703:34;16754:19;;59209:116:0::3;16379:400:1::0;59209:116:0::3;62205:6:::4;58376:1;59785:6;59761:21;59771:10;59761:9;:21::i;:::-;:30;;;;:::i;:::-;:54;;59739:148;;;::::0;-1:-1:-1;;;59739:148:0;;16986:2:1;59739:148:0::4;::::0;::::4;16968:21:1::0;17025:2;17005:18;;;16998:30;17064:34;17044:18;;;17037:62;-1:-1:-1;;;17115:18:1;;;17108:38;17163:19;;59739:148:0::4;16784:404:1::0;59739:148:0::4;62244:6:::5;3729;3704:21;:19;:21::i;:::-;:31;;3696:85;;;::::0;-1:-1:-1;;;3696:85:0;;17395:2:1;3696:85:0::5;::::0;::::5;17377:21:1::0;17434:2;17414:18;;;17407:30;17473:34;17453:18;;;17446:62;-1:-1:-1;;;17524:18:1;;;17517:39;17573:19;;3696:85:0::5;17193:405:1::0;3696:85:0::5;62273:13:::6;62268:110;62300:6;62292:5;:14;62268:110;;;62332:34;62342:10;62354:11;:9;:11::i;:::-;62332:9;:34::i;:::-;62308:7:::0;::::6;::::0;::::6;:::i;:::-;;;;62268:110;;;;62507:20;62517:9;62507;:20::i;:::-;-1:-1:-1::0;;14965:1:0;15919:7;:22;-1:-1:-1;;;;61990:545:0:o;46390:155::-;46485:52;22240:10;46518:8;46528;46485:18;:52::i;47510:323::-;47684:41;22240:10;47717:7;47684:18;:41::i;:::-;47676:100;;;;-1:-1:-1;;;47676:100:0;;;;;;;:::i;:::-;47787:38;47801:4;47807:2;47811:7;47820:4;47787:13;:38::i;65622:383::-;65727:23;65753:20;;;:11;:20;;;;;65727:46;;65696:13;;65727:23;65753:20;65727:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65816:1;65796:9;65790:23;:27;65786:72;;;65841:9;65622:383;-1:-1:-1;;65622:383:0:o;65786:72::-;65963:23;65978:7;65963:14;:23::i;:::-;65946:50;;;;;;;;:::i;:::-;;;;;;;;;;;;;65932:65;;;65622:383;;;:::o;2878:113::-;2930:7;2971:12;:10;:12::i;:::-;2564:10;;2957:26;;;;:::i;24515:201::-;23495:13;:11;:13::i;:::-;-1:-1:-1;;;;;24604:22:0;::::1;24596:73;;;::::0;-1:-1:-1;;;24596:73:0;;18383:2:1;24596:73:0::1;::::0;::::1;18365:21:1::0;18422:2;18402:18;;;18395:30;18461:34;18441:18;;;18434:62;-1:-1:-1;;;18512:18:1;;;18505:36;18558:19;;24596:73:0::1;18181:402:1::0;24596:73:0::1;24680:28;24699:8;24680:18;:28::i;:::-;24515:201:::0;:::o;9770:98::-;9828:7;9855:5;9859:1;9855;:5;:::i;:::-;9848:12;9770:98;-1:-1:-1;;;9770:98:0:o;10169:::-;10227:7;10254:5;10258:1;10254;:5;:::i;43707:305::-;43809:4;-1:-1:-1;;;;;;43846:40:0;;-1:-1:-1;;;43846:40:0;;:105;;-1:-1:-1;;;;;;;43903:48:0;;-1:-1:-1;;;43903:48:0;43846:105;:158;;;-1:-1:-1;;;;;;;;;;36572:40:0;;;43968:36;36463:157;54122:135;49405:4;49429:16;;;:7;:16;;;;;;-1:-1:-1;;;;;49429:16:0;54196:53;;;;-1:-1:-1;;;54196:53:0;;14103:2:1;54196:53:0;;;14085:21:1;14142:2;14122:18;;;14115:30;-1:-1:-1;;;14161:18:1;;;14154:54;14225:18;;54196:53:0;13901:348:1;53401:174:0;53476:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;53476:29:0;-1:-1:-1;;;;;53476:29:0;;;;;;;;:24;;53530:23;53476:24;53530:14;:23::i;:::-;-1:-1:-1;;;;;53521:46:0;;;;;;;;;;;53401:174;;:::o;23774:132::-;23682:6;;-1:-1:-1;;;;;23682:6:0;22240:10;23838:23;23830:68;;;;-1:-1:-1;;;23830:68:0;;18790:2:1;23830:68:0;;;18772:21:1;;;18809:18;;;18802:30;18868:34;18848:18;;;18841:62;18920:18;;23830:68:0;18588:356:1;49634:264:0;49727:4;49744:13;49760:23;49775:7;49760:14;:23::i;:::-;49744:39;;49813:5;-1:-1:-1;;;;;49802:16:0;:7;-1:-1:-1;;;;;49802:16:0;;:52;;;-1:-1:-1;;;;;;46737:25:0;;;46713:4;46737:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;49822:32;49802:87;;;;49882:7;-1:-1:-1;;;;;49858:31:0;:20;49870:7;49858:11;:20::i;:::-;-1:-1:-1;;;;;49858:31:0;;49802:87;49794:96;49634:264;-1:-1:-1;;;;49634:264:0:o;52657:625::-;52816:4;-1:-1:-1;;;;;52789:31:0;:23;52804:7;52789:14;:23::i;:::-;-1:-1:-1;;;;;52789:31:0;;52781:81;;;;-1:-1:-1;;;52781:81:0;;19151:2:1;52781:81:0;;;19133:21:1;19190:2;19170:18;;;19163:30;19229:34;19209:18;;;19202:62;-1:-1:-1;;;19280:18:1;;;19273:35;19325:19;;52781:81:0;18949:401:1;52781:81:0;-1:-1:-1;;;;;52881:16:0;;52873:65;;;;-1:-1:-1;;;52873:65:0;;19557:2:1;52873:65:0;;;19539:21:1;19596:2;19576:18;;;19569:30;19635:34;19615:18;;;19608:62;-1:-1:-1;;;19686:18:1;;;19679:34;19730:19;;52873:65:0;19355:400:1;52873:65:0;53055:29;53072:1;53076:7;53055:8;:29::i;:::-;-1:-1:-1;;;;;53097:15:0;;;;;;:9;:15;;;;;:20;;53116:1;;53097:15;:20;;53116:1;;53097:20;:::i;:::-;;;;-1:-1:-1;;;;;;;53128:13:0;;;;;;:9;:13;;;;;:18;;53145:1;;53128:13;:18;;53145:1;;53128:18;:::i;:::-;;;;-1:-1:-1;;53157:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;53157:21:0;-1:-1:-1;;;;;53157:21:0;;;;;;;;;53196:27;;53157:16;;53196:27;;;;;;;45734:347;45664:417;;:::o;24876:191::-;24969:6;;;-1:-1:-1;;;;;24986:17:0;;;-1:-1:-1;;;;;;24986:17:0;;;;;;;25019:40;;24969:6;;;24986:17;24969:6;;25019:40;;24950:16;;25019:40;24939:128;24876:191;:::o;4889:1262::-;4956:7;3416:1;3392:21;:19;:21::i;:::-;:25;3384:97;;;;-1:-1:-1;;;3384:97:0;;19962:2:1;3384:97:0;;;19944:21:1;20001:2;19981:18;;;19974:30;20040:34;20020:18;;;20013:62;20111:29;20091:18;;;20084:57;20158:19;;3384:97:0;19760:423:1;3384:97:0;4976:16:::1;5009:12;:10;:12::i;:::-;2564:10:::0;;4995:26:::1;;;;:::i;:::-;5081:195;::::0;-1:-1:-1;;5116:10:0::1;20515:2:1::0;20511:15;;;20507:24;;5081:195:0::1;::::0;::::1;20495:37:1::0;5145:14:0::1;20566:15:1::0;;20562:24;20548:12;;;20541:46;5178:16:0::1;20603:12:1::0;;;20596:28;5213:14:0::1;20640:12:1::0;;;20633:28;5246:15:0::1;20677:13:1::0;;;20670:29;4976:45:0;;-1:-1:-1;5032:14:0::1;::::0;4976:45;;20715:13:1;;5081:195:0::1;;;;;;;;;;;;5057:230;;;;;;5049:239;;:250;;;;:::i;:::-;5312:13;5344:19:::0;;;:11:::1;:19;::::0;;;;;5032:267;;-1:-1:-1;5312:13:0;5344:24;;5340:304:::1;;-1:-1:-1::0;5489:6:0;5340:304:::1;;;-1:-1:-1::0;5613:19:0::1;::::0;;;:11:::1;:19;::::0;;;;;5340:304:::1;5721:11;:25;5733:12;5744:1;5733:8:::0;:12:::1;:::i;:::-;5721:25;;;;;;;;;;;;5750:1;5721:30:::0;5717:331:::1;;5855:12;5866:1;5855:8:::0;:12:::1;:::i;:::-;5833:19;::::0;;;:11:::1;:19;::::0;;;;:34;5717:331:::1;;;6011:11;:25;6023:12;6034:1;6023:8:::0;:12:::1;:::i;:::-;6011:25:::0;;::::1;::::0;;::::1;::::0;;;;;;;;-1:-1:-1;6011:25:0;;;;5989:19;;;:11:::1;:19:::0;;;;:47;5717:331:::1;6089:17;:15;:17::i;:::-;-1:-1:-1::0;6134:9:0::1;::::0;6126:17:::1;::::0;:5;:17:::1;:::i;:::-;6119:24;;;;;4889:1262:::0;:::o;50240:110::-;50316:26;50326:2;50330:7;50316:26;;;;;;;;;;;;:9;:26::i;53718:315::-;53873:8;-1:-1:-1;;;;;53864:17:0;:5;-1:-1:-1;;;;;53864:17:0;;53856:55;;;;-1:-1:-1;;;53856:55:0;;21058:2:1;53856:55:0;;;21040:21:1;21097:2;21077:18;;;21070:30;21136:27;21116:18;;;21109:55;21181:18;;53856:55:0;20856:349:1;53856:55:0;-1:-1:-1;;;;;53922:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;53922:46:0;;;;;;;;;;53984:41;;540::1;;;53984::0;;513:18:1;53984:41:0;;;;;;;53718:315;;;:::o;48714:313::-;48870:28;48880:4;48886:2;48890:7;48870:9;:28::i;:::-;48917:47;48940:4;48946:2;48950:7;48959:4;48917:22;:47::i;:::-;48909:110;;;;-1:-1:-1;;;48909:110:0;;;;;;;:::i;44978:281::-;45051:13;45077:23;45092:7;45077:14;:23::i;:::-;45113:21;45137:10;:8;:10::i;:::-;45113:34;;45189:1;45171:7;45165:21;:25;:86;;;;;;;;;;;;;;;;;45217:7;45226:18;:7;:16;:18::i;:::-;45200:45;;;;;;;;;:::i;3101:173::-;3148:7;3168:13;3184:21;:11;995:14;;903:114;3184:21;3168:37;;3218:23;:11;1114:19;;1132:1;1114:19;;;1025:127;3218:23;3261:5;3101:173;-1:-1:-1;3101:173:0:o;50577:319::-;50706:18;50712:2;50716:7;50706:5;:18::i;:::-;50757:53;50788:1;50792:2;50796:7;50805:4;50757:22;:53::i;:::-;50735:153;;;;-1:-1:-1;;;50735:153:0;;;;;;;:::i;54821:853::-;54975:4;-1:-1:-1;;;;;54996:13:0;;26602:19;:23;54992:675;;55032:71;;-1:-1:-1;;;55032:71:0;;-1:-1:-1;;;;;55032:36:0;;;;;:71;;22240:10;;55083:4;;55089:7;;55098:4;;55032:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55032:71:0;;;;;;;;-1:-1:-1;;55032:71:0;;;;;;;;;;;;:::i;:::-;;;55028:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55273:6;:13;55290:1;55273:18;55269:328;;55316:60;;-1:-1:-1;;;55316:60:0;;;;;;;:::i;55269:328::-;55547:6;55541:13;55532:6;55528:2;55524:15;55517:38;55028:584;-1:-1:-1;;;;;;55154:51:0;-1:-1:-1;;;55154:51:0;;-1:-1:-1;55147:58:0;;54992:675;-1:-1:-1;55651:4:0;54821:853;;;;;;:::o;19414:723::-;19470:13;19691:5;19700:1;19691:10;19687:53;;-1:-1:-1;;19718:10:0;;;;;;;;;;;;-1:-1:-1;;;19718:10:0;;;;;19414:723::o;19687:53::-;19765:5;19750:12;19806:78;19813:9;;19806:78;;19839:8;;;;:::i;:::-;;-1:-1:-1;19862:10:0;;-1:-1:-1;19870:2:0;19862:10;;:::i;:::-;;;19806:78;;;19894:19;19926:6;19916:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19916:17:0;;19894:39;;19944:154;19951:10;;19944:154;;19978:11;19988:1;19978:11;;:::i;:::-;;-1:-1:-1;20047:10:0;20055:2;20047:5;:10;:::i;:::-;20034:24;;:2;:24;:::i;:::-;20021:39;;20004:6;20011;20004:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;20004:56:0;;;;;;;;-1:-1:-1;20075:11:0;20084:2;20075:11;;:::i;:::-;;;19944:154;;51232:439;-1:-1:-1;;;;;51312:16:0;;51304:61;;;;-1:-1:-1;;;51304:61:0;;23054:2:1;51304:61:0;;;23036:21:1;;;23073:18;;;23066:30;23132:34;23112:18;;;23105:62;23184:18;;51304:61:0;22852:356:1;51304:61:0;49405:4;49429:16;;;:7;:16;;;;;;-1:-1:-1;;;;;49429:16:0;:30;51376:58;;;;-1:-1:-1;;;51376:58:0;;23415:2:1;51376:58:0;;;23397:21:1;23454:2;23434:18;;;23427:30;23493;23473:18;;;23466:58;23541:18;;51376:58:0;23213:352:1;51376:58:0;-1:-1:-1;;;;;51505:13:0;;;;;;:9;:13;;;;;:18;;51522:1;;51505:13;:18;;51522:1;;51505:18;:::i;:::-;;;;-1:-1:-1;;51534:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;51534:21:0;-1:-1:-1;;;;;51534:21:0;;;;;;;;51573:33;;51534:16;;;51573:33;;51534:16;;51573:33;62978:38:::1;62894:130:::0;:::o;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:1;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:1:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:1;;1343:180;-1:-1:-1;1343:180:1:o;1736:173::-;1804:20;;-1:-1:-1;;;;;1853:31:1;;1843:42;;1833:70;;1899:1;1896;1889:12;1914:254;1982:6;1990;2043:2;2031:9;2022:7;2018:23;2014:32;2011:52;;;2059:1;2056;2049:12;2011:52;2082:29;2101:9;2082:29;:::i;:::-;2072:39;2158:2;2143:18;;;;2130:32;;-1:-1:-1;;;1914:254:1:o;2173:127::-;2234:10;2229:3;2225:20;2222:1;2215:31;2265:4;2262:1;2255:15;2289:4;2286:1;2279:15;2305:275;2376:2;2370:9;2441:2;2422:13;;-1:-1:-1;;2418:27:1;2406:40;;2476:18;2461:34;;2497:22;;;2458:62;2455:88;;;2523:18;;:::i;:::-;2559:2;2552:22;2305:275;;-1:-1:-1;2305:275:1:o;2585:407::-;2650:5;2684:18;2676:6;2673:30;2670:56;;;2706:18;;:::i;:::-;2744:57;2789:2;2768:15;;-1:-1:-1;;2764:29:1;2795:4;2760:40;2744:57;:::i;:::-;2735:66;;2824:6;2817:5;2810:21;2864:3;2855:6;2850:3;2846:16;2843:25;2840:45;;;2881:1;2878;2871:12;2840:45;2930:6;2925:3;2918:4;2911:5;2907:16;2894:43;2984:1;2977:4;2968:6;2961:5;2957:18;2953:29;2946:40;2585:407;;;;;:::o;2997:222::-;3040:5;3093:3;3086:4;3078:6;3074:17;3070:27;3060:55;;3111:1;3108;3101:12;3060:55;3133:80;3209:3;3200:6;3187:20;3180:4;3172:6;3168:17;3133:80;:::i;3224:390::-;3302:6;3310;3363:2;3351:9;3342:7;3338:23;3334:32;3331:52;;;3379:1;3376;3369:12;3331:52;3415:9;3402:23;3392:33;;3476:2;3465:9;3461:18;3448:32;3503:18;3495:6;3492:30;3489:50;;;3535:1;3532;3525:12;3489:50;3558;3600:7;3591:6;3580:9;3576:22;3558:50;:::i;:::-;3548:60;;;3224:390;;;;;:::o;3801:186::-;3860:6;3913:2;3901:9;3892:7;3888:23;3884:32;3881:52;;;3929:1;3926;3919:12;3881:52;3952:29;3971:9;3952:29;:::i;3992:328::-;4069:6;4077;4085;4138:2;4126:9;4117:7;4113:23;4109:32;4106:52;;;4154:1;4151;4144:12;4106:52;4177:29;4196:9;4177:29;:::i;:::-;4167:39;;4225:38;4259:2;4248:9;4244:18;4225:38;:::i;:::-;4215:48;;4310:2;4299:9;4295:18;4282:32;4272:42;;3992:328;;;;;:::o;4325:118::-;4411:5;4404:13;4397:21;4390:5;4387:32;4377:60;;4433:1;4430;4423:12;4448:241;4504:6;4557:2;4545:9;4536:7;4532:23;4528:32;4525:52;;;4573:1;4570;4563:12;4525:52;4612:9;4599:23;4631:28;4653:5;4631:28;:::i;4694:248::-;4762:6;4770;4823:2;4811:9;4802:7;4798:23;4794:32;4791:52;;;4839:1;4836;4829:12;4791:52;-1:-1:-1;;4862:23:1;;;4932:2;4917:18;;;4904:32;;-1:-1:-1;4694:248:1:o;5226:322::-;5295:6;5348:2;5336:9;5327:7;5323:23;5319:32;5316:52;;;5364:1;5361;5354:12;5316:52;5404:9;5391:23;5437:18;5429:6;5426:30;5423:50;;;5469:1;5466;5459:12;5423:50;5492;5534:7;5525:6;5514:9;5510:22;5492:50;:::i;5553:1020::-;5646:6;5654;5707:2;5695:9;5686:7;5682:23;5678:32;5675:52;;;5723:1;5720;5713:12;5675:52;5746:29;5765:9;5746:29;:::i;:::-;5736:39;;5794:2;5847;5836:9;5832:18;5819:32;5870:18;5911:2;5903:6;5900:14;5897:34;;;5927:1;5924;5917:12;5897:34;5965:6;5954:9;5950:22;5940:32;;6010:7;6003:4;5999:2;5995:13;5991:27;5981:55;;6032:1;6029;6022:12;5981:55;6068:2;6055:16;6090:2;6086;6083:10;6080:36;;;6096:18;;:::i;:::-;6142:2;6139:1;6135:10;6125:20;;6165:28;6189:2;6185;6181:11;6165:28;:::i;:::-;6227:15;;;6297:11;;;6293:20;;;6258:12;;;;6325:19;;;6322:39;;;6357:1;6354;6347:12;6322:39;6381:11;;;;6401:142;6417:6;6412:3;6409:15;6401:142;;;6483:17;;6471:30;;6434:12;;;;6521;;;;6401:142;;;6562:5;6552:15;;;;;;;;5553:1020;;;;;:::o;6578:315::-;6643:6;6651;6704:2;6692:9;6683:7;6679:23;6675:32;6672:52;;;6720:1;6717;6710:12;6672:52;6743:29;6762:9;6743:29;:::i;:::-;6733:39;;6822:2;6811:9;6807:18;6794:32;6835:28;6857:5;6835:28;:::i;:::-;6882:5;6872:15;;;6578:315;;;;;:::o;6898:667::-;6993:6;7001;7009;7017;7070:3;7058:9;7049:7;7045:23;7041:33;7038:53;;;7087:1;7084;7077:12;7038:53;7110:29;7129:9;7110:29;:::i;:::-;7100:39;;7158:38;7192:2;7181:9;7177:18;7158:38;:::i;:::-;7148:48;;7243:2;7232:9;7228:18;7215:32;7205:42;;7298:2;7287:9;7283:18;7270:32;7325:18;7317:6;7314:30;7311:50;;;7357:1;7354;7347:12;7311:50;7380:22;;7433:4;7425:13;;7421:27;-1:-1:-1;7411:55:1;;7462:1;7459;7452:12;7411:55;7485:74;7551:7;7546:2;7533:16;7528:2;7524;7520:11;7485:74;:::i;:::-;7475:84;;;6898:667;;;;;;;:::o;7570:260::-;7638:6;7646;7699:2;7687:9;7678:7;7674:23;7670:32;7667:52;;;7715:1;7712;7705:12;7667:52;7738:29;7757:9;7738:29;:::i;:::-;7728:39;;7786:38;7820:2;7809:9;7805:18;7786:38;:::i;:::-;7776:48;;7570:260;;;;;:::o;7835:127::-;7896:10;7891:3;7887:20;7884:1;7877:31;7927:4;7924:1;7917:15;7951:4;7948:1;7941:15;7967:128;8007:3;8038:1;8034:6;8031:1;8028:13;8025:39;;;8044:18;;:::i;:::-;-1:-1:-1;8080:9:1;;7967:128::o;8100:380::-;8179:1;8175:12;;;;8222;;;8243:61;;8297:4;8289:6;8285:17;8275:27;;8243:61;8350:2;8342:6;8339:14;8319:18;8316:38;8313:161;;8396:10;8391:3;8387:20;8384:1;8377:31;8431:4;8428:1;8421:15;8459:4;8456:1;8449:15;8313:161;;8100:380;;;:::o;9444:545::-;9546:2;9541:3;9538:11;9535:448;;;9582:1;9607:5;9603:2;9596:17;9652:4;9648:2;9638:19;9722:2;9710:10;9706:19;9703:1;9699:27;9693:4;9689:38;9758:4;9746:10;9743:20;9740:47;;;-1:-1:-1;9781:4:1;9740:47;9836:2;9831:3;9827:12;9824:1;9820:20;9814:4;9810:31;9800:41;;9891:82;9909:2;9902:5;9899:13;9891:82;;;9954:17;;;9935:1;9924:13;9891:82;;;9895:3;;;9444:545;;;:::o;10165:1352::-;10291:3;10285:10;10318:18;10310:6;10307:30;10304:56;;;10340:18;;:::i;:::-;10369:97;10459:6;10419:38;10451:4;10445:11;10419:38;:::i;:::-;10413:4;10369:97;:::i;:::-;10521:4;;10585:2;10574:14;;10602:1;10597:663;;;;11304:1;11321:6;11318:89;;;-1:-1:-1;11373:19:1;;;11367:26;11318:89;-1:-1:-1;;10122:1:1;10118:11;;;10114:24;10110:29;10100:40;10146:1;10142:11;;;10097:57;11420:81;;10567:944;;10597:663;9391:1;9384:14;;;9428:4;9415:18;;-1:-1:-1;;10633:20:1;;;10751:236;10765:7;10762:1;10759:14;10751:236;;;10854:19;;;10848:26;10833:42;;10946:27;;;;10914:1;10902:14;;;;10781:19;;10751:236;;;10755:3;11015:6;11006:7;11003:19;11000:201;;;11076:19;;;11070:26;-1:-1:-1;;11159:1:1;11155:14;;;11171:3;11151:24;11147:37;11143:42;11128:58;11113:74;;11000:201;-1:-1:-1;;;;;11247:1:1;11231:14;;;11227:22;11214:36;;-1:-1:-1;10165:1352:1:o;11522:410::-;11724:2;11706:21;;;11763:2;11743:18;;;11736:30;11802:34;11797:2;11782:18;;11775:62;-1:-1:-1;;;11868:2:1;11853:18;;11846:44;11922:3;11907:19;;11522:410::o;11937:168::-;11977:7;12043:1;12039;12035:6;12031:14;12028:1;12025:21;12020:1;12013:9;12006:17;12002:45;11999:71;;;12050:18;;:::i;:::-;-1:-1:-1;12090:9:1;;11937:168::o;12110:127::-;12171:10;12166:3;12162:20;12159:1;12152:31;12202:4;12199:1;12192:15;12226:4;12223:1;12216:15;12242:120;12282:1;12308;12298:35;;12313:18;;:::i;:::-;-1:-1:-1;12347:9:1;;12242:120::o;12367:415::-;12569:2;12551:21;;;12608:2;12588:18;;;12581:30;12647:34;12642:2;12627:18;;12620:62;-1:-1:-1;;;12713:2:1;12698:18;;12691:49;12772:3;12757:19;;12367:415::o;13123:184::-;13193:6;13246:2;13234:9;13225:7;13221:23;13217:32;13214:52;;;13262:1;13259;13252:12;13214:52;-1:-1:-1;13285:16:1;;13123:184;-1:-1:-1;13123:184:1:o;13651:245::-;13718:6;13771:2;13759:9;13750:7;13746:23;13742:32;13739:52;;;13787:1;13784;13777:12;13739:52;13819:9;13813:16;13838:28;13860:5;13838:28;:::i;14664:127::-;14725:10;14720:3;14716:20;14713:1;14706:31;14756:4;14753:1;14746:15;14780:4;14777:1;14770:15;15176:135;15215:3;15236:17;;;15233:43;;15256:18;;:::i;:::-;-1:-1:-1;15303:1:1;15292:13;;15176:135::o;17603:443::-;17835:3;17873:6;17867:13;17889:53;17935:6;17930:3;17923:4;17915:6;17911:17;17889:53;:::i;:::-;-1:-1:-1;;;17964:16:1;;17989:22;;;-1:-1:-1;18038:1:1;18027:13;;17603:443;-1:-1:-1;17603:443:1:o;18051:125::-;18091:4;18119:1;18116;18113:8;18110:34;;;18124:18;;:::i;:::-;-1:-1:-1;18161:9:1;;18051:125::o;20739:112::-;20771:1;20797;20787:35;;20802:18;;:::i;:::-;-1:-1:-1;20836:9:1;;20739:112::o;21210:414::-;21412:2;21394:21;;;21451:2;21431:18;;;21424:30;21490:34;21485:2;21470:18;;21463:62;-1:-1:-1;;;21556:2:1;21541:18;;21534:48;21614:3;21599:19;;21210:414::o;21629:470::-;21808:3;21846:6;21840:13;21862:53;21908:6;21903:3;21896:4;21888:6;21884:17;21862:53;:::i;:::-;21978:13;;21937:16;;;;22000:57;21978:13;21937:16;22034:4;22022:17;;22000:57;:::i;:::-;22073:20;;21629:470;-1:-1:-1;;;;21629:470:1:o;22104:489::-;-1:-1:-1;;;;;22373:15:1;;;22355:34;;22425:15;;22420:2;22405:18;;22398:43;22472:2;22457:18;;22450:34;;;22520:3;22515:2;22500:18;;22493:31;;;22298:4;;22541:46;;22567:19;;22559:6;22541:46;:::i;:::-;22533:54;22104:489;-1:-1:-1;;;;;;22104:489:1:o;22598:249::-;22667:6;22720:2;22708:9;22699:7;22695:23;22691:32;22688:52;;;22736:1;22733;22726:12;22688:52;22768:9;22762:16;22787:30;22811:5;22787:30;:::i
Swarm Source
ipfs://86496cd0972a08f2330915f6b9bb19000c74757e3a457f47059c0e25494f8a6d
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.