Token Booster
Overview CRC721
Total Supply:
454 BNFT
Holders:
181 addresses
Contract:
Balance
2 BNFT
[ Download CSV Export ]
[ Download CSV Export ]
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
BoosterNFT
Compiler Version
v0.8.0+commit.c7dfd78e
Contract Source Code (Solidity)
/** *Submitted for verification at cronoscan.com on 2022-02-11 */ /** By interacting with this Solidity Smart Contract you accept the following Terms & Conditions https://bit.ly/3HR6Ly4 */ // SPDX-License-Identifier: MIT 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/token/ERC721/[email protected] 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`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; } // File @openzeppelin/contracts/token/ERC721/[email protected] 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 `IERC721.onERC721Received.selector`. */ function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4); } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] 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/extensions/[email protected] pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File @openzeppelin/contracts/utils/[email protected] pragma solidity ^0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File @openzeppelin/contracts/utils/[email protected] 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) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File @openzeppelin/contracts/utils/[email protected] pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant alphabet = "0123456789abcdef"; /** * @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] = alphabet[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } // File @openzeppelin/contracts/utils/introspection/[email protected] 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/[email protected] 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: balance query for the zero address"); 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: owner query for nonexistent token"); 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) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ''; } /** * @dev Base URI for computing {tokenURI}. Empty by default, can be overriden * in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view 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: transfer caller is not owner nor approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative 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) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ERC721.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, 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); } /** * @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); } /** * @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 of token that is not own"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _balances[from] -= 1; _balances[to] += 1; _owners[tokenId] = to; emit Transfer(from, to, tokenId); } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @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(to).onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { // solhint-disable-next-line no-inline-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` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { } } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override { super._beforeTokenTransfer(from, to, tokenId); if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = ERC721.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete _allTokensIndex[tokenId]; _allTokens.pop(); } } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @title ERC721 Burnable Token * @dev ERC721 Token that can be irreversibly burned (destroyed). */ abstract contract ERC721Burnable is Context, ERC721 { /** * @dev Burns `tokenId`. See {ERC721-_burn}. * * Requirements: * * - The caller must own `tokenId` or be an approved operator. */ function burn(uint256 tokenId) public virtual { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved"); _burn(tokenId); } } // File @openzeppelin/contracts/security/[email protected] pragma solidity ^0.8.0; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor () { _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @dev ERC721 token with pausable token transfers, minting and burning. * * Useful for scenarios such as preventing trades until the end of an evaluation * period, or having an emergency switch for freezing all token transfers in the * event of a large bug. */ abstract contract ERC721Pausable is ERC721, Pausable { /** * @dev See {ERC721-_beforeTokenTransfer}. * * Requirements: * * - the contract must not be paused. */ function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override { super._beforeTokenTransfer(from, to, tokenId); require(!paused(), "ERC721Pausable: token transfer while paused"); } } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @dev ERC721 token with storage based token uri management. */ abstract contract ERC721URIStorage is ERC721 { using Strings for uint256; // Optional mapping for token URIs mapping (uint256 => string) private _tokenURIs; /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = _baseURI(); // If there is no base URI, return the token URI. if (bytes(base).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(base, _tokenURI)); } return super.tokenURI(tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @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 override { super._burn(tokenId); if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } } } // File @openzeppelin/contracts/utils/structs/[email protected] pragma solidity ^0.8.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`) * and `uint256` (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping (bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } // Bytes32Set struct Bytes32Set { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _add(set._inner, value); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) { return _remove(set._inner, value); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) { return _contains(set._inner, value); } /** * @dev Returns the number of values in the set. O(1). */ function length(Bytes32Set storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) { return _at(set._inner, index); } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(uint160(value)))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint160(uint256(_at(set._inner, index)))); } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } pragma solidity ^0.8.0; // Get a link to BEP20 token interface IBep20Token { // Fetch token balance function balanceOf(address account) external view returns (uint256); // Transfer BEP20 token function transfer(address recipient, uint256 amount) external returns (bool); } // File contracts/BoosterNFT.sol pragma solidity ^0.8.0; /** * @title BoosterNFT 1.0 * * @author GambleFi DAO */ contract BoosterNFT is Context, ERC721Enumerable, ERC721URIStorage{ // Base URI for token metadata string private baseTokenURI; // Address of owner address public owner; // Royalty percentage uint8 public royalty; //---Roles defined for different access---// uint8 constant private burnRole = 1; uint8 constant private minterRole = 2; uint8 constant private categorizeRole = 4; // Mapping from tokenId to minting address mapping (uint256 => address) public minter; // Mapping from tokenId to category mapping (uint256 => uint256) public category; // Mapping from address to role mapping (address => uint8) public role; /** * @dev Fired in setRole() * * @param _by an address of owner who executes the function * @param _to an address to which role is assigned * @param _role defines given role */ event Role( address indexed _by, address indexed _to, uint8 _role ); /** * @dev Fired in transferOwnership() when ownership is transferred * * @param _previousOwner an address of previous owner * @param _newOwner an address of new owner */ event OwnershipTransferred(address indexed _previousOwner, address indexed _newOwner); /** * @dev Creates/deploys BoosterNFT Version 1.0 * * @param name_ name of the token * @param symbol_ symbol of the token * @param baseTokenURI_ base URI for token metadata * @param owner_ address of owner * @param royalty_ percentage of royalty */ constructor( string memory name_, string memory symbol_, string memory baseTokenURI_, address owner_, uint8 royalty_ ) ERC721(name_, symbol_) { //---Setup smart contract internal state---// baseTokenURI = baseTokenURI_; owner = owner_; royalty = royalty_; } /** * @dev Returns base URI for token metadata */ function _baseURI() internal view virtual override returns (string memory) { return baseTokenURI; } /** * @dev Sets base URI for token metadata * * @param baseURI_ defines base URI endpoint */ function setBaseURI(string memory baseURI_) external { require(msg.sender == owner, "Only owner can change base URI"); baseTokenURI = baseURI_; } /** * @dev Sets token URI for given tokenId * * @param tokenId_ token Id of BoosterNFT * @param tokenURI_ endpoint URI for given token metadata */ function setTokenURI(uint256 tokenId_, string memory tokenURI_) external { require(msg.sender == owner, "Only owner can change token URI"); _setTokenURI(tokenId_, tokenURI_); } /** * @dev Sets royalty * * @param royalty_ defines royalty percentage */ function setRoyalty(uint8 royalty_) external { require(msg.sender == owner, "Only owner can set royalty"); royalty = royalty_; } /** * @dev Assign role to given address * * @param to_ address to which role is being assigned * @param role_ defines role (1 = burn, 2 = mint, 4 = category), * add role decimals for assigning more than one role */ function setRole(address to_, uint8 role_) external { require(msg.sender == owner, "Only owner can set role"); require(role_ <= 7, "Invalid input"); // Record role data to given address role[to_] = role_; // Emits an event emit Role(msg.sender, to_, role_); } /** * @dev Transfer ownership to given address * * @notice restricted function, should be called by owner only * @param newOwner_ address of new owner */ function transferOwnership(address newOwner_) external { require(msg.sender == owner, "Only owner can transfer ownership"); // Update owner address owner = newOwner_; // Emits an event emit OwnershipTransferred(msg.sender, newOwner_); } /** * @dev Sets catogory for given tokenId * * @param id_ tokenId for which categories to be assigned * @param category_ category index */ function setCategory(uint id_, uint category_) external { uint8 _role = role[msg.sender]; require(_role >= 4, "must have admin role to set category"); require(_exists(id_), "Category set of nonexistent token"); category[id_] = category_; } /** * @dev Sets catogory for given tokenIds * * @param id_ tokenIds for which categories to be assigned * @param category_ category index */ function setCategoryBatch(uint[] memory id_, uint[] memory category_) external { uint8 _role = role[msg.sender]; require(_role >= 4, "must have admin role to set category"); require(id_.length == category_.length, "Invalid input"); for(uint i; i < id_.length; i++) { require(_exists(id_[i]), "Category set of nonexistent token"); category[id_[i]] = category_[i]; } } /** * @dev Mints token to given address * * @param to_ token will be minted to this address * @param id_ tokenId which will be minted to given address */ function mint(address to_, uint256 id_) public { uint8 _role = role[msg.sender]; require( _role >= 2 && _role != 4 && _role != 5, "must have minter role" ); // Mint a token _mint(to_, id_); // Record address for royalty information minter[id_] = to_; } /** * @dev Burns token of given Id * * @param id_ tokenId which will be burned */ function burn(uint256 id_) public { uint8 _role = role[msg.sender]; require( _role >= 1 && _role != 2 && _role !=4 && _role != 6, "must have burn role" ); // Burn a token _burn(id_); // Delete minter address for given Id delete minter[id_]; } /** * @dev See {ERC721URIStorage} */ function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) { return ERC721URIStorage._burn(tokenId); } /** * @dev Returns tokenURI of given tokenId */ function tokenURI(uint256 tokenId) public view override(ERC721, ERC721URIStorage) returns (string memory) { return ERC721URIStorage.tokenURI(tokenId); } /** * @dev Hook that is called before any token transfer */ function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual override(ERC721, ERC721Enumerable) { super._beforeTokenTransfer(from, to, tokenId); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721, ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } /** * @dev Returns royalty info as par the NFT Royalty Standard(EIP-2981) * * @notice Called with the sale price to determine how much royalty * is owed and to whom. * @param id_ the NFT asset queried for royalty information * @param price_ the sale price of the NFT asset specified by id_ * @return receiver_ address of who should be sent the royalty payment * @return royaltyAmount_ the royalty payment amount for price_ */ function royaltyInfo(uint256 id_, uint256 price_) external view returns (address receiver_, uint256 royaltyAmount_) { receiver_ = minter[id_]; royaltyAmount_ = (price_ * royalty) / 100; } /** * @dev Returns NFT type of given token Id * * @param id_ token Id of BoosterNFT */ function getNftType(uint256 id_) external view returns (uint8) { return uint8(category[id_]); } /** * @dev Withdraw BEP20 tokens * * @param token_ address of BEP20 token */ function withdrawTokens(address token_) external { require(msg.sender == owner, "Only owner can withdraw tokens"); // Fetch balance of the contract uint _balance = IBep20Token(token_).balanceOf(address(this)); require(_balance > 0, "Zero balance"); // transfer tokens to owner if balance is non-zero IBep20Token(token_).transfer(msg.sender, _balance); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"string","name":"baseTokenURI_","type":"string"},{"internalType":"address","name":"owner_","type":"address"},{"internalType":"uint8","name":"royalty_","type":"uint8"}],"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":"_by","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":false,"internalType":"uint8","name":"_role","type":"uint8"}],"name":"Role","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id_","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"category","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id_","type":"uint256"}],"name":"getNftType","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"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":[{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint256","name":"id_","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"minter","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"role","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"royalty","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id_","type":"uint256"},{"internalType":"uint256","name":"price_","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":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id_","type":"uint256"},{"internalType":"uint256","name":"category_","type":"uint256"}],"name":"setCategory","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"id_","type":"uint256[]"},{"internalType":"uint256[]","name":"category_","type":"uint256[]"}],"name":"setCategoryBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint8","name":"role_","type":"uint8"}],"name":"setRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint8","name":"royalty_","type":"uint8"}],"name":"setRoyalty","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":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner_","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"}],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e000000000000000000000000000000000000000000000000000000000000001200000000000000000000000002b462c08271b5af84c4a6f55e2d540ddab0b6c2500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000007426f6f73746572000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004424e4654000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : name_ (string): Booster
Arg [1] : symbol_ (string): BNFT
Arg [2] : baseTokenURI_ (string):
Arg [3] : owner_ (address): 0x2b462c08271b5af84c4a6f55e2d540ddab0b6c25
Arg [4] : royalty_ (uint8): 0
-----Encoded View---------------
10 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [3] : 0000000000000000000000002b462c08271b5af84c4a6f55e2d540ddab0b6c25
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000007
Arg [6] : 426f6f7374657200000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [8] : 424e465400000000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000000
Deployed ByteCode Sourcemap
56616:8475:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63422:173;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22690:100;;;:::i;:::-;;;;;;;:::i;24157:221::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;23687:404::-;;;;;;:::i;:::-;;:::i;:::-;;59176:189;;;;;;:::i;:::-;;:::i;35170:113::-;;;:::i;:::-;;;;;;;:::i;25047:305::-;;;;;;:::i;:::-;;:::i;57184:44::-;;;;;;:::i;:::-;;:::i;56838:20::-;;;:::i;:::-;;;;;;;:::i;64095:236::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;61283:440::-;;;;;;:::i;:::-;;:::i;34838:256::-;;;;;;:::i;:::-;;:::i;61907:328::-;;;;;;:::i;:::-;;:::i;25423:151::-;;;;;;:::i;:::-;;:::i;62340:322::-;;;;;;:::i;:::-;;:::i;59475:141::-;;;;;;:::i;:::-;;:::i;64670:416::-;;;;;;:::i;:::-;;:::i;35360:233::-;;;;;;:::i;:::-;;:::i;58829:158::-;;;;;;:::i;:::-;;:::i;59893:308::-;;;;;;:::i;:::-;;:::i;22384:239::-;;;;;;:::i;:::-;;:::i;22114:208::-;;;;;;:::i;:::-;;:::i;56784:20::-;;;:::i;22859:104::-;;;:::i;24450:295::-;;;;;;:::i;:::-;;:::i;64455:103::-;;;;;;:::i;:::-;;:::i;57094:42::-;;;;;;:::i;:::-;;:::i;25645:285::-;;;;;;:::i;:::-;;:::i;62928:160::-;;;;;;:::i;:::-;;:::i;60831:284::-;;;;;;:::i;:::-;;:::i;57272:38::-;;;;;;:::i;:::-;;:::i;24816:164::-;;;;;;:::i;:::-;;:::i;60381:284::-;;;;;;:::i;:::-;;:::i;63422:173::-;63533:4;63553:36;63577:11;63553:23;:36::i;:::-;63546:43;;63422:173;;;;:::o;22690:100::-;22744:13;22777:5;22770:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22690:100;:::o;24157:221::-;24233:7;24261:16;24269:7;24261;:16::i;:::-;24253:73;;;;-1:-1:-1;;;24253:73:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;24346:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;24346:24:0;;24157:221::o;23687:404::-;23768:13;23784:23;23799:7;23784:14;:23::i;:::-;23768:39;;23832:5;-1:-1:-1;;;;;23826:11:0;:2;-1:-1:-1;;;;;23826:11:0;;;23818:57;;;;-1:-1:-1;;;23818:57:0;;;;;;;:::i;:::-;23912:5;-1:-1:-1;;;;;23896:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;23896:21:0;;:69;;;;23921:44;23945:5;23952:12;:10;:12::i;23921:44::-;23888:161;;;;-1:-1:-1;;;23888:161:0;;;;;;;:::i;:::-;24062:21;24071:2;24075:7;24062:8;:21::i;:::-;23687:404;;;:::o;59176:189::-;59278:5;;-1:-1:-1;;;;;59278:5:0;59264:10;:19;59256:63;;;;-1:-1:-1;;;59256:63:0;;;;;;;:::i;:::-;59326:33;59339:8;59349:9;59326:12;:33::i;:::-;59176:189;;:::o;35170:113::-;35258:10;:17;35170:113;:::o;25047:305::-;25208:41;25227:12;:10;:12::i;:::-;25241:7;25208:18;:41::i;:::-;25200:103;;;;-1:-1:-1;;;25200:103:0;;;;;;;:::i;:::-;25316:28;25326:4;25332:2;25336:7;25316:9;:28::i;57184:44::-;;;;;;;;;;;;;:::o;56838:20::-;;;-1:-1:-1;;;56838:20:0;;;;;:::o;64095:236::-;64183:17;64254:11;;;:6;:11;;;;;;64309:7;;-1:-1:-1;;;;;64254:11:0;;;;64183:17;64320:3;;64300:16;;-1:-1:-1;;;64309:7:0;;;;64300:6;:16;:::i;:::-;64299:24;;;;:::i;:::-;64282:41;;64095:236;;;;;:::o;61283:440::-;61394:10;61375:11;61389:16;;;:4;:16;;;;;;;;61435:1;61426:10;;;61418:59;;;;-1:-1:-1;;;61418:59:0;;;;;;;:::i;:::-;61512:9;:16;61498:3;:10;:30;61490:56;;;;-1:-1:-1;;;61490:56:0;;;;;;;:::i;:::-;61559:6;61555:161;61571:3;:10;61567:1;:14;61555:161;;;61609:15;61617:3;61621:1;61617:6;;;;;;-1:-1:-1;;;61617:6:0;;;;;;;;;;;;;;;61609:7;:15::i;:::-;61601:61;;;;-1:-1:-1;;;61601:61:0;;;;;;;:::i;:::-;61694:9;61704:1;61694:12;;;;;;-1:-1:-1;;;61694:12:0;;;;;;;;;;;;;;;61675:8;:16;61684:3;61688:1;61684:6;;;;;;-1:-1:-1;;;61684:6:0;;;;;;;;;;;;;;;61675:16;;;;;;;;;;;:31;;;;61583:3;;;;;:::i;:::-;;;;61555:161;;;;61283:440;;;:::o;34838:256::-;34935:7;34971:23;34988:5;34971:16;:23::i;:::-;34963:5;:31;34955:87;;;;-1:-1:-1;;;34955:87:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;;35060:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;34838:256::o;61907:328::-;61986:10;61967:11;61981:16;;;:4;:16;;;;;;;;62033:1;62024:10;;;;;:24;;;62038:5;:10;;62047:1;62038:10;;62024:24;:38;;;;;62052:5;:10;;62061:1;62052:10;;62024:38;62006:97;;;;-1:-1:-1;;;62006:97:0;;;;;;;:::i;:::-;62133:15;62139:3;62144;62133:5;:15::i;:::-;-1:-1:-1;62208:11:0;;;;:6;:11;;;;;:17;;-1:-1:-1;;;;;;62208:17:0;-1:-1:-1;;;;;62208:17:0;;;;;;;;;;61907:328::o;25423:151::-;25527:39;25544:4;25550:2;25554:7;25527:39;;;;;;;;;;;;:16;:39::i;62340:322::-;62406:10;62387:11;62401:16;;;:4;:16;;;;;;;;;62444:10;;;;;:24;;;62458:5;:10;;62467:1;62458:10;;62444:24;:37;;;;;62472:5;:9;;62480:1;62472:9;;62444:37;:51;;;;;62485:5;:10;;62494:1;62485:10;;62444:51;62426:108;;;;-1:-1:-1;;;62426:108:0;;;;;;;:::i;:::-;62568:10;62574:3;62568:5;:10::i;:::-;-1:-1:-1;62641:11:0;;;;:6;:11;;;;;62634:18;;-1:-1:-1;;;;;;62634:18:0;;;62340:322::o;59475:141::-;59549:5;;-1:-1:-1;;;;;59549:5:0;59535:10;:19;59527:58;;;;-1:-1:-1;;;59527:58:0;;;;;;;:::i;:::-;59592:7;:18;;;;;;-1:-1:-1;;;59592:18:0;-1:-1:-1;;;;59592:18:0;;;;;;;;;59475:141::o;64670:416::-;64754:5;;-1:-1:-1;;;;;64754:5:0;64740:10;:19;64732:62;;;;-1:-1:-1;;;64732:62:0;;;;;;;:::i;:::-;64859:44;;-1:-1:-1;;;64859:44:0;;64843:13;;-1:-1:-1;;;;;64859:29:0;;;;;:44;;64897:4;;64859:44;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;64843:60;;64935:1;64924:8;:12;64916:37;;;;-1:-1:-1;;;64916:37:0;;;;;;;:::i;:::-;65022:50;;-1:-1:-1;;;65022:50:0;;-1:-1:-1;;;;;65022:28:0;;;;;:50;;65051:10;;65063:8;;65022:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;35360:233::-;35435:7;35471:30;:28;:30::i;:::-;35463:5;:38;35455:95;;;;-1:-1:-1;;;35455:95:0;;;;;;;:::i;:::-;35568:10;35579:5;35568:17;;;;;;-1:-1:-1;;;35568:17:0;;;;;;;;;;;;;;;;;35561:24;;35360:233;;;:::o;58829:158::-;58911:5;;-1:-1:-1;;;;;58911:5:0;58897:10;:19;58889:62;;;;-1:-1:-1;;;58889:62:0;;;;;;;:::i;:::-;58958:23;;;;:12;;:23;;;;;:::i;59893:308::-;59980:5;;-1:-1:-1;;;;;59980:5:0;59966:10;:19;59958:55;;;;-1:-1:-1;;;59958:55:0;;;;;;;:::i;:::-;60037:1;60028:5;:10;;;;60020:36;;;;-1:-1:-1;;;60020:36:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;60111:9:0;;;;;;:4;:9;;;;;;;:17;;-1:-1:-1;;60111:17:0;;;;;;;60165:28;60170:10;;60165:28;;;;60111:17;;60165:28;:::i;:::-;;;;;;;;59893:308;;:::o;22384:239::-;22456:7;22492:16;;;:7;:16;;;;;;-1:-1:-1;;;;;22492:16:0;22527:19;22519:73;;;;-1:-1:-1;;;22519:73:0;;;;;;;:::i;22114:208::-;22186:7;-1:-1:-1;;;;;22214:19:0;;22206:74;;;;-1:-1:-1;;;22206:74:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;;22298:16:0;;;;;:9;:16;;;;;;;22114:208::o;56784:20::-;;;-1:-1:-1;;;;;56784:20:0;;:::o;22859:104::-;22915:13;22948:7;22941:14;;;;;:::i;24450:295::-;24565:12;:10;:12::i;:::-;-1:-1:-1;;;;;24553:24:0;:8;-1:-1:-1;;;;;24553:24:0;;;24545:62;;;;-1:-1:-1;;;24545:62:0;;;;;;;:::i;:::-;24665:8;24620:18;:32;24639:12;:10;:12::i;:::-;-1:-1:-1;;;;;24620:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;24620:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;24620:53:0;;;;;;;;;;;24704:12;:10;:12::i;:::-;-1:-1:-1;;;;;24689:48:0;;24728:8;24689:48;;;;;;:::i;64455:103::-;64511:5;64538:13;;;:8;:13;;;;;;;64455:103::o;57094:42::-;;;;;;;;;;;;-1:-1:-1;;;;;57094:42:0;;:::o;25645:285::-;25777:41;25796:12;:10;:12::i;:::-;25810:7;25777:18;:41::i;:::-;25769:103;;;;-1:-1:-1;;;25769:103:0;;;;;;;:::i;:::-;25883:39;25897:4;25903:2;25907:7;25916:5;25883:13;:39::i;62928:160::-;63019:13;63048:34;63074:7;63048:25;:34::i;60831:284::-;60919:10;60900:11;60914:16;;;:4;:16;;;;;;;;60960:1;60951:10;;;60943:59;;;;-1:-1:-1;;;60943:59:0;;;;;;;:::i;:::-;61023:12;61031:3;61023:7;:12::i;:::-;61015:58;;;;-1:-1:-1;;;61015:58:0;;;;;;;:::i;:::-;-1:-1:-1;61082:13:0;;;;:8;:13;;;;;;:25;60831:284::o;57272:38::-;;;;;;;;;;;;;;;:::o;24816:164::-;-1:-1:-1;;;;;24937:25:0;;;24913:4;24937:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;24816:164::o;60381:284::-;60471:5;;-1:-1:-1;;;;;60471:5:0;60457:10;:19;60449:65;;;;-1:-1:-1;;;60449:65:0;;;;;;;:::i;:::-;60552:5;:17;;-1:-1:-1;;;;;;60552:17:0;-1:-1:-1;;;;;60552:17:0;;;;;;;;60610:43;;60631:10;;60610:43;;-1:-1:-1;;60610:43:0;60381:284;:::o;34517:237::-;34619:4;-1:-1:-1;;;;;;34643:50:0;;-1:-1:-1;;;34643:50:0;;:103;;;34710:36;34734:11;34710:23;:36::i;27397:127::-;27462:4;27486:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27486:16:0;:30;;;27397:127::o;17009:98::-;17089:10;17009:98;:::o;31281:174::-;31356:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;31356:29:0;-1:-1:-1;;;;;31356:29:0;;;;;;;;:24;;31410:23;31356:24;31410:14;:23::i;:::-;-1:-1:-1;;;;;31401:46:0;;;;;;;;;;;31281:174;;:::o;45771:217::-;45871:16;45879:7;45871;:16::i;:::-;45863:75;;;;-1:-1:-1;;;45863:75:0;;;;;;;:::i;:::-;45949:19;;;;:10;:19;;;;;;;;:31;;;;;;;;:::i;27691:355::-;27784:4;27809:16;27817:7;27809;:16::i;:::-;27801:73;;;;-1:-1:-1;;;27801:73:0;;;;;;;:::i;:::-;27885:13;27901:23;27916:7;27901:14;:23::i;:::-;27885:39;;27954:5;-1:-1:-1;;;;;27943:16:0;:7;-1:-1:-1;;;;;27943:16:0;;:51;;;;27987:7;-1:-1:-1;;;;;27963:31:0;:20;27975:7;27963:11;:20::i;:::-;-1:-1:-1;;;;;27963:31:0;;27943:51;:94;;;;27998:39;28022:5;28029:7;27998:23;:39::i;:::-;27935:103;27691:355;-1:-1:-1;;;;27691:355:0:o;30619:544::-;30744:4;-1:-1:-1;;;;;30717:31:0;:23;30732:7;30717:14;:23::i;:::-;-1:-1:-1;;;;;30717:31:0;;30709:85;;;;-1:-1:-1;;;30709:85:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;30813:16:0;;30805:65;;;;-1:-1:-1;;;30805:65:0;;;;;;;:::i;:::-;30883:39;30904:4;30910:2;30914:7;30883:20;:39::i;:::-;30987:29;31004:1;31008:7;30987:8;:29::i;:::-;-1:-1:-1;;;;;31029:15:0;;;;;;:9;:15;;;;;:20;;31048:1;;31029:15;:20;;31048:1;;31029:20;:::i;:::-;;;;-1:-1:-1;;;;;;;31060:13:0;;;;;;:9;:13;;;;;:18;;31077:1;;31060:13;:18;;31077:1;;31060:18;:::i;:::-;;;;-1:-1:-1;;31089:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31089:21:0;-1:-1:-1;;;;;31089:21:0;;;;;;;;;31128:27;;31089:16;;31128:27;;;;;;;30619:544;;;:::o;29311:382::-;-1:-1:-1;;;;;29391:16:0;;29383:61;;;;-1:-1:-1;;;29383:61:0;;;;;;;:::i;:::-;29464:16;29472:7;29464;:16::i;:::-;29463:17;29455:58;;;;-1:-1:-1;;;29455:58:0;;;;;;;:::i;:::-;29526:45;29555:1;29559:2;29563:7;29526:20;:45::i;:::-;-1:-1:-1;;;;;29584:13:0;;;;;;:9;:13;;;;;:18;;29601:1;;29584:13;:18;;29601:1;;29584:18;:::i;:::-;;;;-1:-1:-1;;29613:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;29613:21:0;-1:-1:-1;;;;;29613:21:0;;;;;;;;29652:33;;29613:16;;;29652:33;;29613:16;;29652:33;29311:382;;:::o;62722:135::-;62820:31;62843:7;62820:22;:31::i;:::-;62722:135;:::o;26812:272::-;26926:28;26936:4;26942:2;26946:7;26926:9;:28::i;:::-;26973:48;26996:4;27002:2;27006:7;27015:5;26973:22;:48::i;:::-;26965:111;;;;-1:-1:-1;;;26965:111:0;;;;;;;:::i;44936:679::-;45009:13;45043:16;45051:7;45043;:16::i;:::-;45035:78;;;;-1:-1:-1;;;45035:78:0;;;;;;;:::i;:::-;45126:23;45152:19;;;:10;:19;;;;;45126:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45182:18;45203:10;:8;:10::i;:::-;45182:31;;45295:4;45289:18;45311:1;45289:23;45285:72;;;-1:-1:-1;45336:9:0;-1:-1:-1;45329:16:0;;45285:72;45461:23;;:27;45457:108;;45536:4;45542:9;45519:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;45505:48;;;;;;45457:108;45584:23;45599:7;45584:14;:23::i;21758:292::-;21860:4;-1:-1:-1;;;;;;21884:40:0;;-1:-1:-1;;;21884:40:0;;:105;;-1:-1:-1;;;;;;;21941:48:0;;-1:-1:-1;;;21941:48:0;21884:105;:158;;;;22006:36;22030:11;22006:23;:36::i;63171:183::-;63303:45;63330:4;63336:2;63340:7;63303:26;:45::i;46217:206::-;46286:20;46298:7;46286:11;:20::i;:::-;46329:19;;;;:10;:19;;;;;46323:33;;;;;:::i;:::-;:38;;-1:-1:-1;46319:97:0;;46385:19;;;;:10;:19;;;;;46378:26;;;:::i;32020:843::-;32141:4;32167:15;:2;-1:-1:-1;;;;;32167:13:0;;:15::i;:::-;32163:693;;;32219:2;-1:-1:-1;;;;;32203:36:0;;32240:12;:10;:12::i;:::-;32254:4;32260:7;32269:5;32203:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32203:72:0;;;;;;;;-1:-1:-1;;32203:72:0;;;;;;;;;;;;:::i;:::-;;;32199:602;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32449:13:0;;32445:341;;32492:60;;-1:-1:-1;;;32492:60:0;;;;;;;:::i;32445:341::-;32736:6;32730:13;32721:6;32717:2;32713:15;32706:38;32199:602;-1:-1:-1;;;;;;32326:55:0;-1:-1:-1;;;32326:55:0;;-1:-1:-1;32319:62:0;;32163:693;-1:-1:-1;32840:4:0;32020:843;;;;;;:::o;58591:109::-;58651:13;58682:12;58675:19;;;;;:::i;23034:360::-;23107:13;23141:16;23149:7;23141;:16::i;:::-;23133:76;;;;-1:-1:-1;;;23133:76:0;;;;;;;:::i;:::-;23222:21;23246:10;:8;:10::i;:::-;23222:34;;23298:1;23280:7;23274:21;:25;:112;;;;;;;;;;;;;;;;;23339:7;23348:18;:7;:16;:18::i;:::-;23322:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;23274:112;23267:119;23034:360;-1:-1:-1;;;23034:360:0:o;20243:157::-;-1:-1:-1;;;;;;20352:40:0;;-1:-1:-1;;;20352:40:0;20243:157;;;:::o;36206:555::-;36316:45;36343:4;36349:2;36353:7;36316:26;:45::i;:::-;-1:-1:-1;;;;;36378:18:0;;36374:187;;36413:40;36445:7;36413:31;:40::i;:::-;36374:187;;;36483:2;-1:-1:-1;;;;;36475:10:0;:4;-1:-1:-1;;;;;36475:10:0;;36471:90;;36502:47;36535:4;36541:7;36502:32;:47::i;:::-;-1:-1:-1;;;;;36575:16:0;;36571:183;;36608:45;36645:7;36608:36;:45::i;:::-;36571:183;;;36681:4;-1:-1:-1;;;;;36675:10:0;:2;-1:-1:-1;;;;;36675:10:0;;36671:83;;36702:40;36730:2;36734:7;36702:27;:40::i;29922:360::-;29982:13;29998:23;30013:7;29998:14;:23::i;:::-;29982:39;;30034:48;30055:5;30070:1;30074:7;30034:20;:48::i;:::-;30123:29;30140:1;30144:7;30123:8;:29::i;:::-;-1:-1:-1;;;;;30165:16:0;;;;;;:9;:16;;;;;:21;;30185:1;;30165:16;:21;;30185:1;;30165:21;:::i;:::-;;;;-1:-1:-1;;30204:16:0;;;;:7;:16;;;;;;30197:23;;-1:-1:-1;;;;;;30197:23:0;;;30238:36;30212:7;;30204:16;-1:-1:-1;;;;;30238:36:0;;;;;30204:16;;30238:36;29922:360;;:::o;9115:422::-;9482:20;9521:8;;;9115:422::o;17677:723::-;17733:13;17954:10;17950:53;;-1:-1:-1;17981:10:0;;;;;;;;;;;;-1:-1:-1;;;17981:10:0;;;;;;17950:53;18028:5;18013:12;18069:78;18076:9;;18069:78;;18102:8;;;;:::i;:::-;;-1:-1:-1;18125:10:0;;-1:-1:-1;18133:2:0;18125:10;;:::i;:::-;;;18069:78;;;18157:19;18189:6;18179:17;;;;;;-1:-1:-1;;;18179:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18179:17:0;;18157:39;;18207:154;18214:10;;18207:154;;18241:11;18251:1;18241:11;;:::i;:::-;;-1:-1:-1;18310:10:0;18318:2;18310:5;:10;:::i;:::-;18297:24;;:2;:24;:::i;:::-;18284:39;;18267:6;18274;18267:14;;;;;;-1:-1:-1;;;18267:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;18267:56:0;;;;;;;;-1:-1:-1;18338:11:0;18347:2;18338:11;;:::i;:::-;;;18207:154;;37484:164;37588:10;:17;;37561:24;;;;:15;:24;;;;;:44;;;37616:24;;;;;;;;;;;;37484:164::o;38275:988::-;38541:22;38591:1;38566:22;38583:4;38566:16;:22::i;:::-;:26;;;;:::i;:::-;38603:18;38624:26;;;:17;:26;;;;;;38541:51;;-1:-1:-1;38757:28:0;;;38753:328;;-1:-1:-1;;;;;38824:18:0;;38802:19;38824:18;;;:12;:18;;;;;;;;:34;;;;;;;;;38875:30;;;;;;:44;;;38992:30;;:17;:30;;;;;:43;;;38753:328;-1:-1:-1;39177:26:0;;;;:17;:26;;;;;;;;39170:33;;;-1:-1:-1;;;;;39221:18:0;;;;;:12;:18;;;;;:34;;;;;;;39214:41;38275:988::o;39558:1079::-;39836:10;:17;39811:22;;39836:21;;39856:1;;39836:21;:::i;:::-;39868:18;39889:24;;;:15;:24;;;;;;40262:10;:26;;39811:46;;-1:-1:-1;39889:24:0;;39811:46;;40262:26;;;;-1:-1:-1;;;40262:26:0;;;;;;;;;;;;;;;;;40240:48;;40326:11;40301:10;40312;40301:22;;;;;;-1:-1:-1;;;40301:22:0;;;;;;;;;;;;;;;;;;;;:36;;;;40406:28;;;:15;:28;;;;;;;:41;;;40578:24;;;;;40571:31;40613:10;:16;;;;;-1:-1:-1;;;40613:16:0;;;;;;;;;;;;;;;;;;;;;;;;;;39558:1079;;;;:::o;37062:221::-;37147:14;37164:20;37181:2;37164:16;:20::i;:::-;-1:-1:-1;;;;;37195:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;37240:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;37062:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:409:1;;114:18;106:6;103:30;100:2;;;136:18;;:::i;:::-;174:58;220:2;197:17;;-1:-1:-1;;193:31:1;226:4;189:42;174:58;:::i;:::-;165:67;;255:6;248:5;241:21;295:3;286:6;281:3;277:16;274:25;271:2;;;312:1;309;302:12;271:2;361:6;356:3;349:4;342:5;338:16;325:43;415:1;408:4;399:6;392:5;388:18;384:29;377:40;90:333;;;;;:::o;428:175::-;498:20;;-1:-1:-1;;;;;547:31:1;;537:42;;527:2;;593:1;590;583:12;608:749;;721:3;714:4;706:6;702:17;698:27;688:2;;743:5;736;729:20;688:2;783:6;770:20;809:4;832:18;828:2;825:26;822:2;;;854:18;;:::i;:::-;901:2;897;893:11;924:27;947:2;943;939:11;924:27;:::i;:::-;985:15;;;1016:12;;;;1048:15;;;1082;;;1078:24;;1075:33;-1:-1:-1;1072:2:1;;;1125:5;1118;1111:20;1072:2;1151:5;1142:14;;1165:163;1179:2;1176:1;1173:9;1165:163;;;1236:17;;1224:30;;1197:1;1190:9;;;;;1274:12;;;;1306;;1165:163;;;-1:-1:-1;1346:5:1;678:679;-1:-1:-1;;;;;;;678:679:1:o;1362:233::-;;1460:3;1453:4;1445:6;1441:17;1437:27;1427:2;;1482:5;1475;1468:20;1427:2;1508:81;1585:3;1576:6;1563:20;1556:4;1548:6;1544:17;1508:81;:::i;1600:158::-;1668:20;;1728:4;1717:16;;1707:27;;1697:2;;1748:1;1745;1738:12;1763:198;;1875:2;1863:9;1854:7;1850:23;1846:32;1843:2;;;1896:6;1888;1881:22;1843:2;1924:31;1945:9;1924:31;:::i;1966:274::-;;;2095:2;2083:9;2074:7;2070:23;2066:32;2063:2;;;2116:6;2108;2101:22;2063:2;2144:31;2165:9;2144:31;:::i;:::-;2134:41;;2194:40;2230:2;2219:9;2215:18;2194:40;:::i;2245:342::-;;;;2391:2;2379:9;2370:7;2366:23;2362:32;2359:2;;;2412:6;2404;2397:22;2359:2;2440:31;2461:9;2440:31;:::i;:::-;2430:41;;2490:40;2526:2;2515:9;2511:18;2490:40;:::i;:::-;2480:50;;2577:2;2566:9;2562:18;2549:32;2539:42;;2349:238;;;;;:::o;2592:702::-;;;;;2764:3;2752:9;2743:7;2739:23;2735:33;2732:2;;;2786:6;2778;2771:22;2732:2;2814:31;2835:9;2814:31;:::i;:::-;2804:41;;2864:40;2900:2;2889:9;2885:18;2864:40;:::i;:::-;2854:50;;2951:2;2940:9;2936:18;2923:32;2913:42;;3006:2;2995:9;2991:18;2978:32;3033:18;3025:6;3022:30;3019:2;;;3070:6;3062;3055:22;3019:2;3098:22;;3151:4;3143:13;;3139:27;-1:-1:-1;3129:2:1;;3185:6;3177;3170:22;3129:2;3213:75;3280:7;3275:2;3262:16;3257:2;3253;3249:11;3213:75;:::i;:::-;3203:85;;;2722:572;;;;;;;:::o;3299:329::-;;;3425:2;3413:9;3404:7;3400:23;3396:32;3393:2;;;3446:6;3438;3431:22;3393:2;3474:31;3495:9;3474:31;:::i;:::-;3464:41;;3555:2;3544:9;3540:18;3527:32;3568:30;3592:5;3568:30;:::i;:::-;3617:5;3607:15;;;3383:245;;;;;:::o;3633:266::-;;;3762:2;3750:9;3741:7;3737:23;3733:32;3730:2;;;3783:6;3775;3768:22;3730:2;3811:31;3832:9;3811:31;:::i;:::-;3801:41;3889:2;3874:18;;;;3861:32;;-1:-1:-1;;;3720:179:1:o;3904:270::-;;;4031:2;4019:9;4010:7;4006:23;4002:32;3999:2;;;4052:6;4044;4037:22;3999:2;4080:31;4101:9;4080:31;:::i;:::-;4070:41;;4130:38;4164:2;4153:9;4149:18;4130:38;:::i;4179:637::-;;;4358:2;4346:9;4337:7;4333:23;4329:32;4326:2;;;4379:6;4371;4364:22;4326:2;4424:9;4411:23;4453:18;4494:2;4486:6;4483:14;4480:2;;;4515:6;4507;4500:22;4480:2;4543:67;4602:7;4593:6;4582:9;4578:22;4543:67;:::i;:::-;4533:77;;4663:2;4652:9;4648:18;4635:32;4619:48;;4692:2;4682:8;4679:16;4676:2;;;4713:6;4705;4698:22;4676:2;;4741:69;4802:7;4791:8;4780:9;4776:24;4741:69;:::i;:::-;4731:79;;;4316:500;;;;;:::o;4821:257::-;;4941:2;4929:9;4920:7;4916:23;4912:32;4909:2;;;4962:6;4954;4947:22;4909:2;4999:9;4993:16;5018:30;5042:5;5018:30;:::i;5083:257::-;;5194:2;5182:9;5173:7;5169:23;5165:32;5162:2;;;5215:6;5207;5200:22;5162:2;5259:9;5246:23;5278:32;5304:5;5278:32;:::i;5345:261::-;;5467:2;5455:9;5446:7;5442:23;5438:32;5435:2;;;5488:6;5480;5473:22;5435:2;5525:9;5519:16;5544:32;5570:5;5544:32;:::i;5611:344::-;;5733:2;5721:9;5712:7;5708:23;5704:32;5701:2;;;5754:6;5746;5739:22;5701:2;5799:9;5786:23;5832:18;5824:6;5821:30;5818:2;;;5869:6;5861;5854:22;5818:2;5897:52;5941:7;5932:6;5921:9;5917:22;5897:52;:::i;5960:190::-;;6072:2;6060:9;6051:7;6047:23;6043:32;6040:2;;;6093:6;6085;6078:22;6040:2;-1:-1:-1;6121:23:1;;6030:120;-1:-1:-1;6030:120:1:o;6155:194::-;;6278:2;6266:9;6257:7;6253:23;6249:32;6246:2;;;6299:6;6291;6284:22;6246:2;-1:-1:-1;6327:16:1;;6236:113;-1:-1:-1;6236:113:1:o;6354:412::-;;;6493:2;6481:9;6472:7;6468:23;6464:32;6461:2;;;6514:6;6506;6499:22;6461:2;6555:9;6542:23;6532:33;;6616:2;6605:9;6601:18;6588:32;6643:18;6635:6;6632:30;6629:2;;;6680:6;6672;6665:22;6629:2;6708:52;6752:7;6743:6;6732:9;6728:22;6708:52;:::i;6771:258::-;;;6900:2;6888:9;6879:7;6875:23;6871:32;6868:2;;;6921:6;6913;6906:22;6868:2;-1:-1:-1;;6949:23:1;;;7019:2;7004:18;;;6991:32;;-1:-1:-1;6858:171:1:o;7034:194::-;;7144:2;7132:9;7123:7;7119:23;7115:32;7112:2;;;7165:6;7157;7150:22;7112:2;7193:29;7212:9;7193:29;:::i;7233:259::-;;7314:5;7308:12;7341:6;7336:3;7329:19;7357:63;7413:6;7406:4;7401:3;7397:14;7390:4;7383:5;7379:16;7357:63;:::i;:::-;7474:2;7453:15;-1:-1:-1;;7449:29:1;7440:39;;;;7481:4;7436:50;;7284:208;-1:-1:-1;;7284:208:1:o;7497:470::-;;7714:6;7708:13;7730:53;7776:6;7771:3;7764:4;7756:6;7752:17;7730:53;:::i;:::-;7846:13;;7805:16;;;;7868:57;7846:13;7805:16;7902:4;7890:17;;7868:57;:::i;:::-;7941:20;;7684:283;-1:-1:-1;;;;7684:283:1:o;7972:203::-;-1:-1:-1;;;;;8136:32:1;;;;8118:51;;8106:2;8091:18;;8073:102::o;8180:490::-;-1:-1:-1;;;;;8449:15:1;;;8431:34;;8501:15;;8496:2;8481:18;;8474:43;8548:2;8533:18;;8526:34;;;8596:3;8591:2;8576:18;;8569:31;;;8180:490;;8617:47;;8644:19;;8636:6;8617:47;:::i;:::-;8609:55;8383:287;-1:-1:-1;;;;;;8383:287:1:o;8675:274::-;-1:-1:-1;;;;;8867:32:1;;;;8849:51;;8931:2;8916:18;;8909:34;8837:2;8822:18;;8804:145::o;8954:187::-;9119:14;;9112:22;9094:41;;9082:2;9067:18;;9049:92::o;9146:221::-;;9295:2;9284:9;9277:21;9315:46;9357:2;9346:9;9342:18;9334:6;9315:46;:::i;9372:397::-;9574:2;9556:21;;;9613:2;9593:18;;;9586:30;9652:34;9647:2;9632:18;;9625:62;-1:-1:-1;;;9718:2:1;9703:18;;9696:31;9759:3;9744:19;;9546:223::o;9774:400::-;9976:2;9958:21;;;10015:2;9995:18;;;9988:30;10054:34;10049:2;10034:18;;10027:62;-1:-1:-1;;;10120:2:1;10105:18;;10098:34;10164:3;10149:19;;9948:226::o;10179:407::-;10381:2;10363:21;;;10420:2;10400:18;;;10393:30;10459:34;10454:2;10439:18;;10432:62;-1:-1:-1;;;10525:2:1;10510:18;;10503:41;10576:3;10561:19;;10353:233::o;10591:414::-;10793:2;10775:21;;;10832:2;10812:18;;;10805:30;10871:34;10866:2;10851:18;;10844:62;-1:-1:-1;;;10937:2:1;10922:18;;10915:48;10995:3;10980:19;;10765:240::o;11010:345::-;11212:2;11194:21;;;11251:2;11231:18;;;11224:30;-1:-1:-1;;;11285:2:1;11270:18;;11263:51;11346:2;11331:18;;11184:171::o;11360:347::-;11562:2;11544:21;;;11601:2;11581:18;;;11574:30;11640:25;11635:2;11620:18;;11613:53;11698:2;11683:18;;11534:173::o;11712:352::-;11914:2;11896:21;;;11953:2;11933:18;;;11926:30;11992;11987:2;11972:18;;11965:58;12055:2;12040:18;;11886:178::o;12069:350::-;12271:2;12253:21;;;12310:2;12290:18;;;12283:30;12349:28;12344:2;12329:18;;12322:56;12410:2;12395:18;;12243:176::o;12424:400::-;12626:2;12608:21;;;12665:2;12645:18;;;12638:30;12704:34;12699:2;12684:18;;12677:62;-1:-1:-1;;;12770:2:1;12755:18;;12748:34;12814:3;12799:19;;12598:226::o;12829:354::-;13031:2;13013:21;;;13070:2;13050:18;;;13043:30;13109:32;13104:2;13089:18;;13082:60;13174:2;13159:18;;13003:180::o;13188:349::-;13390:2;13372:21;;;13429:2;13409:18;;;13402:30;13468:27;13463:2;13448:18;;13441:55;13528:2;13513:18;;13362:175::o;13542:397::-;13744:2;13726:21;;;13783:2;13763:18;;;13756:30;13822:34;13817:2;13802:18;;13795:62;-1:-1:-1;;;13888:2:1;13873:18;;13866:31;13929:3;13914:19;;13716:223::o;13944:408::-;14146:2;14128:21;;;14185:2;14165:18;;;14158:30;14224:34;14219:2;14204:18;;14197:62;-1:-1:-1;;;14290:2:1;14275:18;;14268:42;14342:3;14327:19;;14118:234::o;14357:420::-;14559:2;14541:21;;;14598:2;14578:18;;;14571:30;14637:34;14632:2;14617:18;;14610:62;14708:26;14703:2;14688:18;;14681:54;14767:3;14752:19;;14531:246::o;14782:355::-;14984:2;14966:21;;;15023:2;15003:18;;;14996:30;15062:33;15057:2;15042:18;;15035:61;15128:2;15113:18;;14956:181::o;15142:406::-;15344:2;15326:21;;;15383:2;15363:18;;;15356:30;15422:34;15417:2;15402:18;;15395:62;-1:-1:-1;;;15488:2:1;15473:18;;15466:40;15538:3;15523:19;;15316:232::o;15553:405::-;15755:2;15737:21;;;15794:2;15774:18;;;15767:30;15833:34;15828:2;15813:18;;15806:62;-1:-1:-1;;;15899:2:1;15884:18;;15877:39;15948:3;15933:19;;15727:231::o;15963:410::-;16165:2;16147:21;;;16204:2;16184:18;;;16177:30;16243:34;16238:2;16223:18;;16216:62;-1:-1:-1;;;16309:2:1;16294:18;;16287:44;16363:3;16348:19;;16137:236::o;16378:356::-;16580:2;16562:21;;;16599:18;;;16592:30;16658:34;16653:2;16638:18;;16631:62;16725:2;16710:18;;16552:182::o;16739:413::-;16941:2;16923:21;;;16980:2;16960:18;;;16953:30;17019:34;17014:2;16999:18;;16992:62;-1:-1:-1;;;17085:2:1;17070:18;;17063:47;17142:3;17127:19;;16913:239::o;17157:408::-;17359:2;17341:21;;;17398:2;17378:18;;;17371:30;17437:34;17432:2;17417:18;;17410:62;-1:-1:-1;;;17503:2:1;17488:18;;17481:42;17555:3;17540:19;;17331:234::o;17570:405::-;17772:2;17754:21;;;17811:2;17791:18;;;17784:30;17850:34;17845:2;17830:18;;17823:62;-1:-1:-1;;;17916:2:1;17901:18;;17894:39;17965:3;17950:19;;17744:231::o;17980:411::-;18182:2;18164:21;;;18221:2;18201:18;;;18194:30;18260:34;18255:2;18240:18;;18233:62;-1:-1:-1;;;18326:2:1;18311:18;;18304:45;18381:3;18366:19;;18154:237::o;18396:337::-;18598:2;18580:21;;;18637:2;18617:18;;;18610:30;-1:-1:-1;;;18671:2:1;18656:18;;18649:43;18724:2;18709:18;;18570:163::o;18738:397::-;18940:2;18922:21;;;18979:2;18959:18;;;18952:30;19018:34;19013:2;18998:18;;18991:62;-1:-1:-1;;;19084:2:1;19069:18;;19062:31;19125:3;19110:19;;18912:223::o;19140:413::-;19342:2;19324:21;;;19381:2;19361:18;;;19354:30;19420:34;19415:2;19400:18;;19393:62;-1:-1:-1;;;19486:2:1;19471:18;;19464:47;19543:3;19528:19;;19314:239::o;19558:354::-;19760:2;19742:21;;;19799:2;19779:18;;;19772:30;19838:32;19833:2;19818:18;;19811:60;19903:2;19888:18;;19732:180::o;19917:408::-;20119:2;20101:21;;;20158:2;20138:18;;;20131:30;20197:34;20192:2;20177:18;;20170:62;-1:-1:-1;;;20263:2:1;20248:18;;20241:42;20315:3;20300:19;;20091:234::o;20330:343::-;20532:2;20514:21;;;20571:2;20551:18;;;20544:30;-1:-1:-1;;;20605:2:1;20590:18;;20583:49;20664:2;20649:18;;20504:169::o;20678:336::-;20880:2;20862:21;;;20919:2;20899:18;;;20892:30;-1:-1:-1;;;20953:2:1;20938:18;;20931:42;21005:2;20990:18;;20852:162::o;21019:177::-;21165:25;;;21153:2;21138:18;;21120:76::o;21201:184::-;21373:4;21361:17;;;;21343:36;;21331:2;21316:18;;21298:87::o;21390:251::-;21460:2;21454:9;21490:17;;;21537:18;21522:34;;21558:22;;;21519:62;21516:2;;;21584:18;;:::i;:::-;21620:2;21613:22;21434:207;;-1:-1:-1;21434:207:1:o;21646:128::-;;21717:1;21713:6;21710:1;21707:13;21704:2;;;21723:18;;:::i;:::-;-1:-1:-1;21759:9:1;;21694:80::o;21779:120::-;;21845:1;21835:2;;21850:18;;:::i;:::-;-1:-1:-1;21884:9:1;;21825:74::o;21904:168::-;;22010:1;22006;22002:6;21998:14;21995:1;21992:21;21987:1;21980:9;21973:17;21969:45;21966:2;;;22017:18;;:::i;:::-;-1:-1:-1;22057:9:1;;21956:116::o;22077:125::-;;22145:1;22142;22139:8;22136:2;;;22150:18;;:::i;:::-;-1:-1:-1;22187:9:1;;22126:76::o;22207:258::-;22279:1;22289:113;22303:6;22300:1;22297:13;22289:113;;;22379:11;;;22373:18;22360:11;;;22353:39;22325:2;22318:10;22289:113;;;22420:6;22417:1;22414:13;22411:2;;;-1:-1:-1;;22455:1:1;22437:16;;22430:27;22260:205::o;22470:380::-;22555:1;22545:12;;22602:1;22592:12;;;22613:2;;22667:4;22659:6;22655:17;22645:27;;22613:2;22720;22712:6;22709:14;22689:18;22686:38;22683:2;;;22766:10;22761:3;22757:20;22754:1;22747:31;22801:4;22798:1;22791:15;22829:4;22826:1;22819:15;22683:2;;22525:325;;;:::o;22855:135::-;;-1:-1:-1;;22915:17:1;;22912:2;;;22935:18;;:::i;:::-;-1:-1:-1;22982:1:1;22971:13;;22902:88::o;22995:112::-;;23053:1;23043:2;;23058:18;;:::i;:::-;-1:-1:-1;23092:9:1;;23033:74::o;23112:127::-;23173:10;23168:3;23164:20;23161:1;23154:31;23204:4;23201:1;23194:15;23228:4;23225:1;23218:15;23244:127;23305:10;23300:3;23296:20;23293:1;23286:31;23336:4;23333:1;23326:15;23360:4;23357:1;23350:15;23376:127;23437:10;23432:3;23428:20;23425:1;23418:31;23468:4;23465:1;23458:15;23492:4;23489:1;23482:15;23508:120;23596:5;23589:13;23582:21;23575:5;23572:32;23562:2;;23618:1;23615;23608:12;23633:133;-1:-1:-1;;;;;;23709:32:1;;23699:43;;23689:2;;23756:1;23753;23746:12
Swarm Source
ipfs://c3925055f174699169b2110b1a347475cabd47a4e90704a97a6d0eca8d1cc97b