Token YourValoraPersona
Overview ERC721
Total Supply:
276,792 YVP
Holders:
260,002 addresses
Contract:
Balance
1 YVP
[ Download CSV Export ]
[ Download CSV Export ]
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
ValoraWrappedArchetypes
Compiler Version
v0.8.4+commit.c7e474f2
Contract Source Code (Solidity Standard Json-Input format)
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `to`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address to, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `from` to `to` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 amount ) external returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/ERC721.sol) pragma solidity ^0.8.0; import "./IERC721.sol"; import "./IERC721Receiver.sol"; import "./extensions/IERC721Metadata.sol"; import "../../utils/Address.sol"; import "../../utils/Context.sol"; import "../../utils/Strings.sol"; import "../../utils/introspection/ERC165.sol"; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: address zero is not a valid owner"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _ownerOf(tokenId); require(owner != address(0), "ERC721: invalid token ID"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overridden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not token owner or approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { _requireMinted(tokenId); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { _setApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: caller is not token owner or 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 the owner of the `tokenId`. Does NOT revert if token doesn't exist */ function _ownerOf(uint256 tokenId) internal view virtual returns (address) { return _owners[tokenId]; } /** * @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 _ownerOf(tokenId) != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { address owner = ERC721.ownerOf(tokenId); return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == spender); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId, 1); // Check that tokenId was not minted by `_beforeTokenTransfer` hook require(!_exists(tokenId), "ERC721: token already minted"); unchecked { // Will not overflow unless all 2**256 token ids are minted to the same owner. // Given that tokens are minted one by one, it is impossible in practice that // this ever happens. Might change if we allow batch minting. // The ERC fails to describe this case. _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); _afterTokenTransfer(address(0), to, tokenId, 1); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * This is an internal function that does not check if the sender is authorized to operate on the token. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId, 1); // Update ownership in case tokenId was transferred by `_beforeTokenTransfer` hook owner = ERC721.ownerOf(tokenId); // Clear approvals delete _tokenApprovals[tokenId]; unchecked { // Cannot overflow, as that would require more tokens to be burned/transferred // out than the owner initially received through minting and transferring in. _balances[owner] -= 1; } delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); _afterTokenTransfer(owner, address(0), tokenId, 1); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId, 1); // Check that tokenId was not transferred by `_beforeTokenTransfer` hook require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner"); // Clear approvals from the previous owner delete _tokenApprovals[tokenId]; unchecked { // `_balances[from]` cannot overflow for the same reason as described in `_burn`: // `from`'s balance is the number of token held, which is at least one before the current // transfer. // `_balances[to]` could overflow in the conditions described in `_mint`. That would require // all 2**256 token ids to be minted, which in practice is impossible. _balances[from] -= 1; _balances[to] += 1; } _owners[tokenId] = to; emit Transfer(from, to, tokenId); _afterTokenTransfer(from, to, tokenId, 1); } /** * @dev Approve `to` to operate on `tokenId` * * Emits an {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Approve `operator` to operate on all of `owner` tokens * * Emits an {ApprovalForAll} event. */ function _setApprovalForAll( address owner, address operator, bool approved ) internal virtual { require(owner != operator, "ERC721: approve to caller"); _operatorApprovals[owner][operator] = approved; emit ApprovalForAll(owner, operator, approved); } /** * @dev Reverts if the `tokenId` has not been minted yet. */ function _requireMinted(uint256 tokenId) internal view virtual { require(_exists(tokenId), "ERC721: invalid token ID"); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, data) returns (bytes4 retval) { return retval == IERC721Receiver.onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { /// @solidity memory-safe-assembly assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens will be transferred to `to`. * - When `from` is zero, the tokens will be minted for `to`. * - When `to` is zero, ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256, /* firstTokenId */ uint256 batchSize ) internal virtual { if (batchSize > 1) { if (from != address(0)) { _balances[from] -= batchSize; } if (to != address(0)) { _balances[to] += batchSize; } } } /** * @dev Hook that is called after any token transfer. This includes minting and burning. If {ERC721Consecutive} is * used, the hook may be called as part of a consecutive (batch) mint, as indicated by `batchSize` greater than 1. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s tokens were transferred to `to`. * - When `from` is zero, the tokens were minted for `to`. * - When `to` is zero, ``from``'s tokens were burned. * - `from` and `to` are never both zero. * - `batchSize` is non-zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _afterTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual {} }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/extensions/ERC721Enumerable.sol) pragma solidity ^0.8.0; import "../ERC721.sol"; import "./IERC721Enumerable.sol"; /** * @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 See {ERC721-_beforeTokenTransfer}. */ function _beforeTokenTransfer( address from, address to, uint256 firstTokenId, uint256 batchSize ) internal virtual override { super._beforeTokenTransfer(from, to, firstTokenId, batchSize); if (batchSize > 1) { // Will only trigger during construction. Batch transferring (minting) is not available afterwards. revert("ERC721Enumerable: consecutive transfers not supported"); } uint256 tokenId = firstTokenId; 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(); } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol) pragma solidity ^0.8.0; import "../IERC721.sol"; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol) pragma solidity ^0.8.0; import "../../utils/introspection/IERC165.sol"; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721 * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must * understand this adds an external call which potentially creates a reentrancy vulnerability. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol) pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol) pragma solidity ^0.8.1; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== * * [IMPORTANT] * ==== * You shouldn't rely on `isContract` to protect against flash loan attacks! * * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract * constructor. * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize/address.code.length, which returns 0 // for contracts in construction, since the code is only stored at the end // of the constructor execution. return account.code.length > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, "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"); (bool success, bytes memory returndata) = target.call{value: value}(data); return verifyCallResultFromTarget(target, 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) { (bool success, bytes memory returndata) = target.staticcall(data); return verifyCallResultFromTarget(target, 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) { (bool success, bytes memory returndata) = target.delegatecall(data); return verifyCallResultFromTarget(target, success, returndata, errorMessage); } /** * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract. * * _Available since v4.8._ */ function verifyCallResultFromTarget( address target, bool success, bytes memory returndata, string memory errorMessage ) internal view returns (bytes memory) { if (success) { if (returndata.length == 0) { // only check isContract if the call was successful and the return data is empty // otherwise we already know that it was a contract require(isContract(target), "Address: call to non-contract"); } return returndata; } else { _revert(returndata, errorMessage); } } /** * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the * revert reason or using the provided one. * * _Available since v4.3._ */ function verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) internal pure returns (bytes memory) { if (success) { return returndata; } else { _revert(returndata, errorMessage); } } function _revert(bytes memory returndata, string memory errorMessage) private pure { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly /// @solidity memory-safe-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; import "./IERC165.sol"; /** * @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; } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol) pragma solidity ^0.8.0; /** * @dev Standard math utilities missing in the Solidity language. */ library Math { enum Rounding { Down, // Toward negative infinity Up, // Toward infinity Zero // Toward zero } /** * @dev Returns the largest of two numbers. */ function max(uint256 a, uint256 b) internal pure returns (uint256) { return a > b ? a : b; } /** * @dev Returns the smallest of two numbers. */ function min(uint256 a, uint256 b) internal pure returns (uint256) { return a < b ? a : b; } /** * @dev Returns the average of two numbers. The result is rounded towards * zero. */ function average(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b) / 2 can overflow. return (a & b) + (a ^ b) / 2; } /** * @dev Returns the ceiling of the division of two numbers. * * This differs from standard division with `/` in that it rounds up instead * of rounding down. */ function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) { // (a + b - 1) / b can overflow on addition, so we distribute. return a == 0 ? 0 : (a - 1) / b + 1; } /** * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0 * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) * with further edits by Uniswap Labs also under MIT license. */ function mulDiv( uint256 x, uint256 y, uint256 denominator ) internal pure returns (uint256 result) { unchecked { // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256 // variables such that product = prod1 * 2^256 + prod0. uint256 prod0; // Least significant 256 bits of the product uint256 prod1; // Most significant 256 bits of the product assembly { let mm := mulmod(x, y, not(0)) prod0 := mul(x, y) prod1 := sub(sub(mm, prod0), lt(mm, prod0)) } // Handle non-overflow cases, 256 by 256 division. if (prod1 == 0) { return prod0 / denominator; } // Make sure the result is less than 2^256. Also prevents denominator == 0. require(denominator > prod1); /////////////////////////////////////////////// // 512 by 256 division. /////////////////////////////////////////////// // Make division exact by subtracting the remainder from [prod1 prod0]. uint256 remainder; assembly { // Compute remainder using mulmod. remainder := mulmod(x, y, denominator) // Subtract 256 bit number from 512 bit number. prod1 := sub(prod1, gt(remainder, prod0)) prod0 := sub(prod0, remainder) } // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1. // See https://cs.stackexchange.com/q/138556/92363. // Does not overflow because the denominator cannot be zero at this stage in the function. uint256 twos = denominator & (~denominator + 1); assembly { // Divide denominator by twos. denominator := div(denominator, twos) // Divide [prod1 prod0] by twos. prod0 := div(prod0, twos) // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one. twos := add(div(sub(0, twos), twos), 1) } // Shift in bits from prod1 into prod0. prod0 |= prod1 * twos; // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for // four bits. That is, denominator * inv = 1 mod 2^4. uint256 inverse = (3 * denominator) ^ 2; // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works // in modular arithmetic, doubling the correct bits in each step. inverse *= 2 - denominator * inverse; // inverse mod 2^8 inverse *= 2 - denominator * inverse; // inverse mod 2^16 inverse *= 2 - denominator * inverse; // inverse mod 2^32 inverse *= 2 - denominator * inverse; // inverse mod 2^64 inverse *= 2 - denominator * inverse; // inverse mod 2^128 inverse *= 2 - denominator * inverse; // inverse mod 2^256 // Because the division is now exact we can divide by multiplying with the modular inverse of denominator. // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1 // is no longer required. result = prod0 * inverse; return result; } } /** * @notice Calculates x * y / denominator with full precision, following the selected rounding direction. */ function mulDiv( uint256 x, uint256 y, uint256 denominator, Rounding rounding ) internal pure returns (uint256) { uint256 result = mulDiv(x, y, denominator); if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) { result += 1; } return result; } /** * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down. * * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11). */ function sqrt(uint256 a) internal pure returns (uint256) { if (a == 0) { return 0; } // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target. // // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`. // // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)` // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))` // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)` // // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit. uint256 result = 1 << (log2(a) >> 1); // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128, // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision // into the expected uint128 result. unchecked { result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; result = (result + a / result) >> 1; return min(result, a / result); } } /** * @notice Calculates sqrt(a), following the selected rounding direction. */ function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = sqrt(a); return result + (rounding == Rounding.Up && result * result < a ? 1 : 0); } } /** * @dev Return the log in base 2, rounded down, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 128; } if (value >> 64 > 0) { value >>= 64; result += 64; } if (value >> 32 > 0) { value >>= 32; result += 32; } if (value >> 16 > 0) { value >>= 16; result += 16; } if (value >> 8 > 0) { value >>= 8; result += 8; } if (value >> 4 > 0) { value >>= 4; result += 4; } if (value >> 2 > 0) { value >>= 2; result += 2; } if (value >> 1 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 2, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log2(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log2(value); return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0); } } /** * @dev Return the log in base 10, rounded down, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >= 10**64) { value /= 10**64; result += 64; } if (value >= 10**32) { value /= 10**32; result += 32; } if (value >= 10**16) { value /= 10**16; result += 16; } if (value >= 10**8) { value /= 10**8; result += 8; } if (value >= 10**4) { value /= 10**4; result += 4; } if (value >= 10**2) { value /= 10**2; result += 2; } if (value >= 10**1) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log10(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log10(value); return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0); } } /** * @dev Return the log in base 256, rounded down, of a positive value. * Returns 0 if given 0. * * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string. */ function log256(uint256 value) internal pure returns (uint256) { uint256 result = 0; unchecked { if (value >> 128 > 0) { value >>= 128; result += 16; } if (value >> 64 > 0) { value >>= 64; result += 8; } if (value >> 32 > 0) { value >>= 32; result += 4; } if (value >> 16 > 0) { value >>= 16; result += 2; } if (value >> 8 > 0) { result += 1; } } return result; } /** * @dev Return the log in base 10, following the selected rounding direction, of a positive value. * Returns 0 if given 0. */ function log256(uint256 value, Rounding rounding) internal pure returns (uint256) { unchecked { uint256 result = log256(value); return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0); } } }
// SPDX-License-Identifier: MIT // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol) pragma solidity ^0.8.0; import "./math/Math.sol"; /** * @dev String operations. */ library Strings { bytes16 private constant _SYMBOLS = "0123456789abcdef"; uint8 private constant _ADDRESS_LENGTH = 20; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { unchecked { uint256 length = Math.log10(value) + 1; string memory buffer = new string(length); uint256 ptr; /// @solidity memory-safe-assembly assembly { ptr := add(buffer, add(32, length)) } while (true) { ptr--; /// @solidity memory-safe-assembly assembly { mstore8(ptr, byte(mod(value, 10), _SYMBOLS)) } value /= 10; if (value == 0) break; } return buffer; } } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { unchecked { return toHexString(value, Math.log256(value) + 1); } } /** * @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] = _SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } /** * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation. */ function toHexString(address addr) internal pure returns (string memory) { return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH); } }
// SPDX-License-Identifier: UNLICENSED pragma solidity ^0.8.4; import "@openzeppelin/contracts/token/ERC721/ERC721.sol"; import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol"; import "@openzeppelin/contracts/access/Ownable.sol"; import "@openzeppelin/contracts/token/ERC20/IERC20.sol"; contract ValoraWrappedArchetypes is Ownable, ERC721Enumerable { using Strings for uint256; mapping(uint256 => string) private _tokenURIs; constructor() ERC721("YourValoraPersona", "YVP") { } function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { _requireMinted(tokenId); string memory _tokenURI = _tokenURIs[tokenId]; require(bytes(_tokenURIs[tokenId]).length != 0); return _tokenURI; } function mint(address _to, string memory _tokenUri) public onlyOwner payable returns (uint256) { uint256 supply = totalSupply(); uint256 tokenId = supply + 1; _safeMint(_to, tokenId); _tokenURIs[tokenId] = _tokenUri; return tokenId; } function mintAll(address[] memory _to, string[] memory _tokenUri) public onlyOwner payable returns (uint256[] memory) { require(_to.length == _tokenUri.length, "Mismatched array lengths"); uint256[] memory tokenIds = new uint256[](_to.length); for (uint256 i = 0; i < _to.length; i++) { tokenIds[i] = mint(_to[i], _tokenUri[i]); } return tokenIds; } // // We don't expect to hold any CELO or ERC-20 tokens, but just in case some // end up in the contract. // function withdraw() public payable onlyOwner { require(payable(msg.sender).send(address(this).balance), "Transfer Failed"); } function withdrawERC20(IERC20 token) public onlyOwner { require(token.transfer(msg.sender, token.balanceOf(address(this))), "Transfer failed"); } }
{ "optimizer": { "enabled": false, "runs": 200 }, "outputSelection": { "*": { "*": [ "evm.bytecode", "evm.deployedBytecode", "abi" ] } }, "metadata": { "useLiteralContent": true } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"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":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"string","name":"_tokenUri","type":"string"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_to","type":"address[]"},{"internalType":"string[]","name":"_tokenUri","type":"string[]"}],"name":"mintAll","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"withdrawERC20","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed ByteCode Sourcemap
312:1509:14:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1005:222:5;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2471:98:2;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3935:167;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3468:406;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1630:111:5;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4612:326:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1306:253:5;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1533:131:14;;;:::i;:::-;;5004:179:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1813:230:5;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2190:219:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1929:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1831:101:0;;;;;;;;;;;;;:::i;:::-;;1201:85;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2633:102:2;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1035:377:14;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4169:153:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5249:314;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;515:255:14;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;774:257;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4388:162:2;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2081:198:0;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1668:151:14;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1005:222:5;1107:4;1145:35;1130:50;;;:11;:50;;;;:90;;;;1184:36;1208:11;1184:23;:36::i;:::-;1130:90;1123:97;;1005:222;;;:::o;2471:98:2:-;2525:13;2557:5;2550:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2471:98;:::o;3935:167::-;4011:7;4030:23;4045:7;4030:14;:23::i;:::-;4071:15;:24;4087:7;4071:24;;;;;;;;;;;;;;;;;;;;;4064:31;;3935:167;;;:::o;3468:406::-;3548:13;3564:23;3579:7;3564:14;:23::i;:::-;3548:39;;3611:5;3605:11;;:2;:11;;;;3597:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;3702:5;3686:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;3711:37;3728:5;3735:12;:10;:12::i;:::-;3711:16;:37::i;:::-;3686:62;3665:170;;;;;;;;;;;;:::i;:::-;;;;;;;;;3846:21;3855:2;3859:7;3846:8;:21::i;:::-;3468:406;;;:::o;1630:111:5:-;1691:7;1717:10;:17;;;;1710:24;;1630:111;:::o;4612:326:2:-;4801:41;4820:12;:10;:12::i;:::-;4834:7;4801:18;:41::i;:::-;4793:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;4903:28;4913:4;4919:2;4923:7;4903:9;:28::i;:::-;4612:326;;;:::o;1306:253:5:-;1403:7;1438:23;1455:5;1438:16;:23::i;:::-;1430:5;:31;1422:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;1526:12;:19;1539:5;1526:19;;;;;;;;;;;;;;;:26;1546:5;1526:26;;;;;;;;;;;;1519:33;;1306:253;;;;:::o;1533:131:14:-;1094:13:0;:11;:13::i;:::-;1600:10:14::1;1592:24;;:47;1617:21;1592:47;;;;;;;;;;;;;;;;;;;;;;;1584:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;1533:131::o:0;5004:179:2:-;5137:39;5154:4;5160:2;5164:7;5137:39;;;;;;;;;;;;:16;:39::i;:::-;5004:179;;;:::o;1813:230:5:-;1888:7;1923:30;:28;:30::i;:::-;1915:5;:38;1907:95;;;;;;;;;;;;:::i;:::-;;;;;;;;;2019:10;2030:5;2019:17;;;;;;;;;;;;;;;;;;;;;;;;2012:24;;1813:230;;;:::o;2190:219:2:-;2262:7;2281:13;2297:17;2306:7;2297:8;:17::i;:::-;2281:33;;2349:1;2332:19;;:5;:19;;;;2324:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;2397:5;2390:12;;;2190:219;;;:::o;1929:204::-;2001:7;2045:1;2028:19;;:5;:19;;;;2020:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2110:9;:16;2120:5;2110:16;;;;;;;;;;;;;;;;2103:23;;1929:204;;;:::o;1831:101:0:-;1094:13;:11;:13::i;:::-;1895:30:::1;1922:1;1895:18;:30::i;:::-;1831:101::o:0;1201:85::-;1247:7;1273:6;;;;;;;;;;;1266:13;;1201:85;:::o;2633:102:2:-;2689:13;2721:7;2714:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2633:102;:::o;1035:377:14:-;1135:16;1094:13:0;:11;:13::i;:::-;1181:9:14::1;:16;1167:3;:10;:30;1159:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;1232:25;1274:3;:10;1260:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1232:53;;1296:9;1291:96;1315:3;:10;1311:1;:14;1291:96;;;1354:26;1359:3;1363:1;1359:6;;;;;;;;;;;;;;;;;;;;;;1367:9;1377:1;1367:12;;;;;;;;;;;;;;;;;;;;;;1354:4;:26::i;:::-;1340:8;1349:1;1340:11;;;;;;;;;;;;;;;;;;;;;:40;;;::::0;::::1;1327:3;;;;;:::i;:::-;;;;1291:96;;;;1399:8;1392:15;;;1035:377:::0;;;;:::o;4169:153:2:-;4263:52;4282:12;:10;:12::i;:::-;4296:8;4306;4263:18;:52::i;:::-;4169:153;;:::o;5249:314::-;5417:41;5436:12;:10;:12::i;:::-;5450:7;5417:18;:41::i;:::-;5409:99;;;;;;;;;;;;:::i;:::-;;;;;;;;;5518:38;5532:4;5538:2;5542:7;5551:4;5518:13;:38::i;:::-;5249:314;;;;:::o;515:255:14:-;588:13;609:23;624:7;609:14;:23::i;:::-;638;664:10;:19;675:7;664:19;;;;;;;;;;;638:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;734:1;703:10;:19;714:7;703:19;;;;;;;;;;;697:33;;;;;:::i;:::-;;;:38;;689:47;;;;;;756:9;749:16;;;515:255;;;:::o;774:257::-;860:7;1094:13:0;:11;:13::i;:::-;875:14:14::1;892:13;:11;:13::i;:::-;875:30;;911:15;938:1;929:6;:10;;;;:::i;:::-;911:28;;945:23;955:3;960:7;945:9;:23::i;:::-;996:9;974:10;:19;985:7;974:19;;;;;;;;;;;:31;;;;;;;;;;;;:::i;:::-;;1019:7;1012:14;;;;774:257:::0;;;;:::o;4388:162:2:-;4485:4;4508:18;:25;4527:5;4508:25;;;;;;;;;;;;;;;:35;4534:8;4508:35;;;;;;;;;;;;;;;;;;;;;;;;;4501:42;;4388:162;;;;:::o;2081:198:0:-;1094:13;:11;:13::i;:::-;2189:1:::1;2169:22;;:8;:22;;;;2161:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;2244:28;2263:8;2244:18;:28::i;:::-;2081:198:::0;:::o;1668:151:14:-;1094:13:0;:11;:13::i;:::-;1736:5:14::1;:14;;;1751:10;1763:5;:15;;;1787:4;1763:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1736:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;1728:86;;;;;;;;;;;;:::i;:::-;;;;;;;;;1668:151:::0;:::o;1570:300:2:-;1672:4;1722:25;1707:40;;;:11;:40;;;;:104;;;;1778:33;1763:48;;;:11;:48;;;;1707:104;:156;;;;1827:36;1851:11;1827:23;:36::i;:::-;1707:156;1688:175;;1570:300;;;:::o;13466:133::-;13547:16;13555:7;13547;:16::i;:::-;13539:53;;;;;;;;;;;;:::i;:::-;;;;;;;;;13466:133;:::o;640:96:9:-;693:7;719:10;712:17;;640:96;:::o;12768:171:2:-;12869:2;12842:15;:24;12858:7;12842:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;12924:7;12920:2;12886:46;;12895:23;12910:7;12895:14;:23::i;:::-;12886:46;;;;;;;;;;;;12768:171;;:::o;7540:261::-;7633:4;7649:13;7665:23;7680:7;7665:14;:23::i;:::-;7649:39;;7717:5;7706:16;;:7;:16;;;:52;;;;7726:32;7743:5;7750:7;7726:16;:32::i;:::-;7706:52;:87;;;;7786:7;7762:31;;:20;7774:7;7762:11;:20::i;:::-;:31;;;7706:87;7698:96;;;7540:261;;;;:::o;11423:1233::-;11577:4;11550:31;;:23;11565:7;11550:14;:23::i;:::-;:31;;;11542:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;11655:1;11641:16;;:2;:16;;;;11633:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;11709:42;11730:4;11736:2;11740:7;11749:1;11709:20;:42::i;:::-;11878:4;11851:31;;:23;11866:7;11851:14;:23::i;:::-;:31;;;11843:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;11993:15;:24;12009:7;11993:24;;;;;;;;;;;;11986:31;;;;;;;;;;;12480:1;12461:9;:15;12471:4;12461:15;;;;;;;;;;;;;;;;:20;;;;;;;;;;;12512:1;12495:9;:13;12505:2;12495:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;12552:2;12533:7;:16;12541:7;12533:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;12589:7;12585:2;12570:27;;12579:4;12570:27;;;;;;;;;;;;12608:41;12628:4;12634:2;12638:7;12647:1;12608:19;:41::i;:::-;11423:1233;;;:::o;1359:130:0:-;1433:12;:10;:12::i;:::-;1422:23;;:7;:5;:7::i;:::-;:23;;;1414:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;1359:130::o;6838:115:2:-;6904:7;6930;:16;6938:7;6930:16;;;;;;;;;;;;;;;;;;;;;6923:23;;6838:115;;;:::o;2433:187:0:-;2506:16;2525:6;;;;;;;;;;;2506:25;;2550:8;2541:6;;:17;;;;;;;;;;;;;;;;;;2604:8;2573:40;;2594:8;2573:40;;;;;;;;;;;;2433:187;;:::o;13075:307:2:-;13225:8;13216:17;;:5;:17;;;;13208:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;13311:8;13273:18;:25;13292:5;13273:25;;;;;;;;;;;;;;;:35;13299:8;13273:35;;;;;;;;;;;;;;;;:46;;;;;;;;;;;;;;;;;;13356:8;13334:41;;13349:5;13334:41;;;13366:8;13334:41;;;;;;:::i;:::-;;;;;;;;13075:307;;;:::o;6424:305::-;6574:28;6584:4;6590:2;6594:7;6574:9;:28::i;:::-;6620:47;6643:4;6649:2;6653:7;6662:4;6620:22;:47::i;:::-;6612:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;6424:305;;;;:::o;8131:108::-;8206:26;8216:2;8220:7;8206:26;;;;;;;;;;;;:9;:26::i;:::-;8131:108;;:::o;829:155:11:-;914:4;952:25;937:40;;;:11;:40;;;;930:47;;829:155;;;:::o;7256:126:2:-;7321:4;7373:1;7344:31;;:17;7353:7;7344:8;:17::i;:::-;:31;;;;7337:38;;7256:126;;;:::o;2112:890:5:-;2283:61;2310:4;2316:2;2320:12;2334:9;2283:26;:61::i;:::-;2371:1;2359:9;:13;2355:219;;;2500:63;;;;;;;;;;:::i;:::-;;;;;;;;2355:219;2584:15;2602:12;2584:30;;2645:1;2629:18;;:4;:18;;;2625:183;;;2663:40;2695:7;2663:31;:40::i;:::-;2625:183;;;2732:2;2724:10;;:4;:10;;;2720:88;;2750:47;2783:4;2789:7;2750:32;:47::i;:::-;2720:88;2625:183;2835:1;2821:16;;:2;:16;;;2817:179;;;2853:45;2890:7;2853:36;:45::i;:::-;2817:179;;;2925:4;2919:10;;:2;:10;;;2915:81;;2945:40;2973:2;2977:7;2945:27;:40::i;:::-;2915:81;2817:179;2112:890;;;;;:::o;16800:153:2:-;;;;;:::o;14151:831::-;14300:4;14320:15;:2;:13;;;:15::i;:::-;14316:660;;;14371:2;14355:36;;;14392:12;:10;:12::i;:::-;14406:4;14412:7;14421:4;14355:71;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;14351:573;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14610:1;14593:6;:13;:18;14589:321;;;14635:60;;;;;;;;;;:::i;:::-;;;;;;;;14589:321;14862:6;14856:13;14847:6;14843:2;14839:15;14832:38;14351:573;14486:41;;;14476:51;;;:6;:51;;;;14469:58;;;;;14316:660;14961:4;14954:11;;14151:831;;;;;;;:::o;8460:309::-;8584:18;8590:2;8594:7;8584:5;:18::i;:::-;8633:53;8664:1;8668:2;8672:7;8681:4;8633:22;:53::i;:::-;8612:150;;;;;;;;;;;;:::i;:::-;;;;;;;;;8460:309;;;:::o;15698:396::-;15882:1;15870:9;:13;15866:222;;;15919:1;15903:18;;:4;:18;;;15899:85;;15960:9;15941;:15;15951:4;15941:15;;;;;;;;;;;;;;;;:28;;;;;;;:::i;:::-;;;;;;;;15899:85;16015:1;16001:16;;:2;:16;;;15997:81;;16054:9;16037;:13;16047:2;16037:13;;;;;;;;;;;;;;;;:26;;;;;;;:::i;:::-;;;;;;;;15997:81;15866:222;15698:396;;;;:::o;3708:161:5:-;3811:10;:17;;;;3784:15;:24;3800:7;3784:24;;;;;;;;;;;:44;;;;3838:10;3854:7;3838:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3708:161;:::o;4486:970::-;4748:22;4798:1;4773:22;4790:4;4773:16;:22::i;:::-;:26;;;;:::i;:::-;4748:51;;4809:18;4830:17;:26;4848:7;4830:26;;;;;;;;;;;;4809:47;;4974:14;4960:10;:28;4956:323;;5004:19;5026:12;:18;5039:4;5026:18;;;;;;;;;;;;;;;:34;5045:14;5026:34;;;;;;;;;;;;5004:56;;5108:11;5075:12;:18;5088:4;5075:18;;;;;;;;;;;;;;;:30;5094:10;5075:30;;;;;;;;;;;:44;;;;5224:10;5191:17;:30;5209:11;5191:30;;;;;;;;;;;:43;;;;4956:323;;5372:17;:26;5390:7;5372:26;;;;;;;;;;;5365:33;;;5415:12;:18;5428:4;5415:18;;;;;;;;;;;;;;;:34;5434:14;5415:34;;;;;;;;;;;5408:41;;;4486:970;;;;:::o;5744:1061::-;5993:22;6038:1;6018:10;:17;;;;:21;;;;:::i;:::-;5993:46;;6049:18;6070:15;:24;6086:7;6070:24;;;;;;;;;;;;6049:45;;6416:19;6438:10;6449:14;6438:26;;;;;;;;;;;;;;;;;;;;;;;;6416:48;;6500:11;6475:10;6486;6475:22;;;;;;;;;;;;;;;;;;;;;;;:36;;;;6610:10;6579:15;:28;6595:11;6579:28;;;;;;;;;;;:41;;;;6748:15;:24;6764:7;6748:24;;;;;;;;;;;6741:31;;;6782:10;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5744:1061;;;;:::o;3296:217::-;3380:14;3397:20;3414:2;3397:16;:20::i;:::-;3380:37;;3454:7;3427:12;:16;3440:2;3427:16;;;;;;;;;;;;;;;:24;3444:6;3427:24;;;;;;;;;;;:34;;;;3500:6;3471:17;:26;3489:7;3471:26;;;;;;;;;;;:35;;;;3296:217;;;:::o;1175:320:8:-;1235:4;1487:1;1465:7;:19;;;:23;1458:30;;1175:320;;;:::o;9091:920:2:-;9184:1;9170:16;;:2;:16;;;;9162:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;9242:16;9250:7;9242;:16::i;:::-;9241:17;9233:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;9302:48;9331:1;9335:2;9339:7;9348:1;9302:20;:48::i;:::-;9446:16;9454:7;9446;:16::i;:::-;9445:17;9437:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;9854:1;9837:9;:13;9847:2;9837:13;;;;;;;;;;;;;;;;:18;;;;;;;;;;;9895:2;9876:7;:16;9884:7;9876:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;9938:7;9934:2;9913:33;;9930:1;9913:33;;;;;;;;;;;;9957:47;9985:1;9989:2;9993:7;10002:1;9957:19;:47::i;:::-;9091:920;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;24:655:15:-;120:5;145:81;161:64;218:6;161:64;:::i;:::-;145:81;:::i;:::-;136:90;;246:5;275:6;268:5;261:21;309:4;302:5;298:16;291:23;;335:6;385:3;377:4;369:6;365:17;360:3;356:27;353:36;350:2;;;414:1;411;404:12;350:2;450:1;435:238;460:6;457:1;454:13;435:238;;;528:3;557:37;590:3;578:10;557:37;:::i;:::-;552:3;545:50;624:4;619:3;615:14;608:21;;658:4;653:3;649:14;642:21;;495:178;482:1;479;475:9;470:14;;435:238;;;439:14;126:553;;;;;;;:::o;701:823::-;807:5;832:91;848:74;915:6;848:74;:::i;:::-;832:91;:::i;:::-;823:100;;943:5;972:6;965:5;958:21;1006:4;999:5;995:16;988:23;;1032:6;1082:3;1074:4;1066:6;1062:17;1057:3;1053:27;1050:36;1047:2;;;1111:1;1108;1101:12;1047:2;1147:1;1132:386;1157:6;1154:1;1151:13;1132:386;;;1239:3;1226:17;1275:18;1262:11;1259:35;1256:2;;;1307:1;1304;1297:12;1256:2;1354:11;1346:6;1342:24;1392:47;1435:3;1423:10;1392:47;:::i;:::-;1387:3;1380:60;1469:4;1464:3;1460:14;1453:21;;1503:4;1498:3;1494:14;1487:21;;1192:326;;1179:1;1176;1172:9;1167:14;;1132:386;;;1136:14;813:711;;;;;;;:::o;1530:343::-;1607:5;1632:65;1648:48;1689:6;1648:48;:::i;:::-;1632:65;:::i;:::-;1623:74;;1720:6;1713:5;1706:21;1758:4;1751:5;1747:16;1796:3;1787:6;1782:3;1778:16;1775:25;1772:2;;;1813:1;1810;1803:12;1772:2;1826:41;1860:6;1855:3;1850;1826:41;:::i;:::-;1613:260;;;;;;:::o;1879:345::-;1957:5;1982:66;1998:49;2040:6;1998:49;:::i;:::-;1982:66;:::i;:::-;1973:75;;2071:6;2064:5;2057:21;2109:4;2102:5;2098:16;2147:3;2138:6;2133:3;2129:16;2126:25;2123:2;;;2164:1;2161;2154:12;2123:2;2177:41;2211:6;2206:3;2201;2177:41;:::i;:::-;1963:261;;;;;;:::o;2230:139::-;2276:5;2314:6;2301:20;2292:29;;2330:33;2357:5;2330:33;:::i;:::-;2282:87;;;;:::o;2392:303::-;2463:5;2512:3;2505:4;2497:6;2493:17;2489:27;2479:2;;2530:1;2527;2520:12;2479:2;2570:6;2557:20;2595:94;2685:3;2677:6;2670:4;2662:6;2658:17;2595:94;:::i;:::-;2586:103;;2469:226;;;;;:::o;2717:323::-;2798:5;2847:3;2840:4;2832:6;2828:17;2824:27;2814:2;;2865:1;2862;2855:12;2814:2;2905:6;2892:20;2930:104;3030:3;3022:6;3015:4;3007:6;3003:17;2930:104;:::i;:::-;2921:113;;2804:236;;;;;:::o;3046:133::-;3089:5;3127:6;3114:20;3105:29;;3143:30;3167:5;3143:30;:::i;:::-;3095:84;;;;:::o;3185:137::-;3239:5;3270:6;3264:13;3255:22;;3286:30;3310:5;3286:30;:::i;:::-;3245:77;;;;:::o;3328:137::-;3373:5;3411:6;3398:20;3389:29;;3427:32;3453:5;3427:32;:::i;:::-;3379:86;;;;:::o;3471:141::-;3527:5;3558:6;3552:13;3543:22;;3574:32;3600:5;3574:32;:::i;:::-;3533:79;;;;:::o;3631:271::-;3686:5;3735:3;3728:4;3720:6;3716:17;3712:27;3702:2;;3753:1;3750;3743:12;3702:2;3793:6;3780:20;3818:78;3892:3;3884:6;3877:4;3869:6;3865:17;3818:78;:::i;:::-;3809:87;;3692:210;;;;;:::o;3908:167::-;3968:5;4006:6;3993:20;3984:29;;4022:47;4063:5;4022:47;:::i;:::-;3974:101;;;;:::o;4095:273::-;4151:5;4200:3;4193:4;4185:6;4181:17;4177:27;4167:2;;4218:1;4215;4208:12;4167:2;4258:6;4245:20;4283:79;4358:3;4350:6;4343:4;4335:6;4331:17;4283:79;:::i;:::-;4274:88;;4157:211;;;;;:::o;4374:139::-;4420:5;4458:6;4445:20;4436:29;;4474:33;4501:5;4474:33;:::i;:::-;4426:87;;;;:::o;4519:143::-;4576:5;4607:6;4601:13;4592:22;;4623:33;4650:5;4623:33;:::i;:::-;4582:80;;;;:::o;4668:262::-;4727:6;4776:2;4764:9;4755:7;4751:23;4747:32;4744:2;;;4792:1;4789;4782:12;4744:2;4835:1;4860:53;4905:7;4896:6;4885:9;4881:22;4860:53;:::i;:::-;4850:63;;4806:117;4734:196;;;;:::o;4936:407::-;5004:6;5012;5061:2;5049:9;5040:7;5036:23;5032:32;5029:2;;;5077:1;5074;5067:12;5029:2;5120:1;5145:53;5190:7;5181:6;5170:9;5166:22;5145:53;:::i;:::-;5135:63;;5091:117;5247:2;5273:53;5318:7;5309:6;5298:9;5294:22;5273:53;:::i;:::-;5263:63;;5218:118;5019:324;;;;;:::o;5349:552::-;5426:6;5434;5442;5491:2;5479:9;5470:7;5466:23;5462:32;5459:2;;;5507:1;5504;5497:12;5459:2;5550:1;5575:53;5620:7;5611:6;5600:9;5596:22;5575:53;:::i;:::-;5565:63;;5521:117;5677:2;5703:53;5748:7;5739:6;5728:9;5724:22;5703:53;:::i;:::-;5693:63;;5648:118;5805:2;5831:53;5876:7;5867:6;5856:9;5852:22;5831:53;:::i;:::-;5821:63;;5776:118;5449:452;;;;;:::o;5907:809::-;6002:6;6010;6018;6026;6075:3;6063:9;6054:7;6050:23;6046:33;6043:2;;;6092:1;6089;6082:12;6043:2;6135:1;6160:53;6205:7;6196:6;6185:9;6181:22;6160:53;:::i;:::-;6150:63;;6106:117;6262:2;6288:53;6333:7;6324:6;6313:9;6309:22;6288:53;:::i;:::-;6278:63;;6233:118;6390:2;6416:53;6461:7;6452:6;6441:9;6437:22;6416:53;:::i;:::-;6406:63;;6361:118;6546:2;6535:9;6531:18;6518:32;6577:18;6569:6;6566:30;6563:2;;;6609:1;6606;6599:12;6563:2;6637:62;6691:7;6682:6;6671:9;6667:22;6637:62;:::i;:::-;6627:72;;6489:220;6033:683;;;;;;;:::o;6722:401::-;6787:6;6795;6844:2;6832:9;6823:7;6819:23;6815:32;6812:2;;;6860:1;6857;6850:12;6812:2;6903:1;6928:53;6973:7;6964:6;6953:9;6949:22;6928:53;:::i;:::-;6918:63;;6874:117;7030:2;7056:50;7098:7;7089:6;7078:9;7074:22;7056:50;:::i;:::-;7046:60;;7001:115;6802:321;;;;;:::o;7129:520::-;7207:6;7215;7264:2;7252:9;7243:7;7239:23;7235:32;7232:2;;;7280:1;7277;7270:12;7232:2;7323:1;7348:53;7393:7;7384:6;7373:9;7369:22;7348:53;:::i;:::-;7338:63;;7294:117;7478:2;7467:9;7463:18;7450:32;7509:18;7501:6;7498:30;7495:2;;;7541:1;7538;7531:12;7495:2;7569:63;7624:7;7615:6;7604:9;7600:22;7569:63;:::i;:::-;7559:73;;7421:221;7222:427;;;;;:::o;7655:407::-;7723:6;7731;7780:2;7768:9;7759:7;7755:23;7751:32;7748:2;;;7796:1;7793;7786:12;7748:2;7839:1;7864:53;7909:7;7900:6;7889:9;7885:22;7864:53;:::i;:::-;7854:63;;7810:117;7966:2;7992:53;8037:7;8028:6;8017:9;8013:22;7992:53;:::i;:::-;7982:63;;7937:118;7738:324;;;;;:::o;8068:713::-;8196:6;8204;8253:2;8241:9;8232:7;8228:23;8224:32;8221:2;;;8269:1;8266;8259:12;8221:2;8340:1;8329:9;8325:17;8312:31;8370:18;8362:6;8359:30;8356:2;;;8402:1;8399;8392:12;8356:2;8430:78;8500:7;8491:6;8480:9;8476:22;8430:78;:::i;:::-;8420:88;;8283:235;8585:2;8574:9;8570:18;8557:32;8616:18;8608:6;8605:30;8602:2;;;8648:1;8645;8638:12;8602:2;8676:88;8756:7;8747:6;8736:9;8732:22;8676:88;:::i;:::-;8666:98;;8528:246;8211:570;;;;;:::o;8787:278::-;8854:6;8903:2;8891:9;8882:7;8878:23;8874:32;8871:2;;;8919:1;8916;8909:12;8871:2;8962:1;8987:61;9040:7;9031:6;9020:9;9016:22;8987:61;:::i;:::-;8977:71;;8933:125;8861:204;;;;:::o;9071:260::-;9129:6;9178:2;9166:9;9157:7;9153:23;9149:32;9146:2;;;9194:1;9191;9184:12;9146:2;9237:1;9262:52;9306:7;9297:6;9286:9;9282:22;9262:52;:::i;:::-;9252:62;;9208:116;9136:195;;;;:::o;9337:282::-;9406:6;9455:2;9443:9;9434:7;9430:23;9426:32;9423:2;;;9471:1;9468;9461:12;9423:2;9514:1;9539:63;9594:7;9585:6;9574:9;9570:22;9539:63;:::i;:::-;9529:73;;9485:127;9413:206;;;;:::o;9625:290::-;9698:6;9747:2;9735:9;9726:7;9722:23;9718:32;9715:2;;;9763:1;9760;9753:12;9715:2;9806:1;9831:67;9890:7;9881:6;9870:9;9866:22;9831:67;:::i;:::-;9821:77;;9777:131;9705:210;;;;:::o;9921:262::-;9980:6;10029:2;10017:9;10008:7;10004:23;10000:32;9997:2;;;10045:1;10042;10035:12;9997:2;10088:1;10113:53;10158:7;10149:6;10138:9;10134:22;10113:53;:::i;:::-;10103:63;;10059:117;9987:196;;;;:::o;10189:284::-;10259:6;10308:2;10296:9;10287:7;10283:23;10279:32;10276:2;;;10324:1;10321;10314:12;10276:2;10367:1;10392:64;10448:7;10439:6;10428:9;10424:22;10392:64;:::i;:::-;10382:74;;10338:128;10266:207;;;;:::o;10479:179::-;10548:10;10569:46;10611:3;10603:6;10569:46;:::i;:::-;10647:4;10642:3;10638:14;10624:28;;10559:99;;;;:::o;10664:118::-;10751:24;10769:5;10751:24;:::i;:::-;10746:3;10739:37;10729:53;;:::o;10818:732::-;10937:3;10966:54;11014:5;10966:54;:::i;:::-;11036:86;11115:6;11110:3;11036:86;:::i;:::-;11029:93;;11146:56;11196:5;11146:56;:::i;:::-;11225:7;11256:1;11241:284;11266:6;11263:1;11260:13;11241:284;;;11342:6;11336:13;11369:63;11428:3;11413:13;11369:63;:::i;:::-;11362:70;;11455:60;11508:6;11455:60;:::i;:::-;11445:70;;11301:224;11288:1;11285;11281:9;11276:14;;11241:284;;;11245:14;11541:3;11534:10;;10942:608;;;;;;;:::o;11556:109::-;11637:21;11652:5;11637:21;:::i;:::-;11632:3;11625:34;11615:50;;:::o;11671:360::-;11757:3;11785:38;11817:5;11785:38;:::i;:::-;11839:70;11902:6;11897:3;11839:70;:::i;:::-;11832:77;;11918:52;11963:6;11958:3;11951:4;11944:5;11940:16;11918:52;:::i;:::-;11995:29;12017:6;11995:29;:::i;:::-;11990:3;11986:39;11979:46;;11761:270;;;;;:::o;12037:364::-;12125:3;12153:39;12186:5;12153:39;:::i;:::-;12208:71;12272:6;12267:3;12208:71;:::i;:::-;12201:78;;12288:52;12333:6;12328:3;12321:4;12314:5;12310:16;12288:52;:::i;:::-;12365:29;12387:6;12365:29;:::i;:::-;12360:3;12356:39;12349:46;;12129:272;;;;;:::o;12407:366::-;12549:3;12570:67;12634:2;12629:3;12570:67;:::i;:::-;12563:74;;12646:93;12735:3;12646:93;:::i;:::-;12764:2;12759:3;12755:12;12748:19;;12553:220;;;:::o;12779:366::-;12921:3;12942:67;13006:2;13001:3;12942:67;:::i;:::-;12935:74;;13018:93;13107:3;13018:93;:::i;:::-;13136:2;13131:3;13127:12;13120:19;;12925:220;;;:::o;13151:366::-;13293:3;13314:67;13378:2;13373:3;13314:67;:::i;:::-;13307:74;;13390:93;13479:3;13390:93;:::i;:::-;13508:2;13503:3;13499:12;13492:19;;13297:220;;;:::o;13523:366::-;13665:3;13686:67;13750:2;13745:3;13686:67;:::i;:::-;13679:74;;13762:93;13851:3;13762:93;:::i;:::-;13880:2;13875:3;13871:12;13864:19;;13669:220;;;:::o;13895:366::-;14037:3;14058:67;14122:2;14117:3;14058:67;:::i;:::-;14051:74;;14134:93;14223:3;14134:93;:::i;:::-;14252:2;14247:3;14243:12;14236:19;;14041:220;;;:::o;14267:366::-;14409:3;14430:67;14494:2;14489:3;14430:67;:::i;:::-;14423:74;;14506:93;14595:3;14506:93;:::i;:::-;14624:2;14619:3;14615:12;14608:19;;14413:220;;;:::o;14639:366::-;14781:3;14802:67;14866:2;14861:3;14802:67;:::i;:::-;14795:74;;14878:93;14967:3;14878:93;:::i;:::-;14996:2;14991:3;14987:12;14980:19;;14785:220;;;:::o;15011:366::-;15153:3;15174:67;15238:2;15233:3;15174:67;:::i;:::-;15167:74;;15250:93;15339:3;15250:93;:::i;:::-;15368:2;15363:3;15359:12;15352:19;;15157:220;;;:::o;15383:366::-;15525:3;15546:67;15610:2;15605:3;15546:67;:::i;:::-;15539:74;;15622:93;15711:3;15622:93;:::i;:::-;15740:2;15735:3;15731:12;15724:19;;15529:220;;;:::o;15755:366::-;15897:3;15918:67;15982:2;15977:3;15918:67;:::i;:::-;15911:74;;15994:93;16083:3;15994:93;:::i;:::-;16112:2;16107:3;16103:12;16096:19;;15901:220;;;:::o;16127:366::-;16269:3;16290:67;16354:2;16349:3;16290:67;:::i;:::-;16283:74;;16366:93;16455:3;16366:93;:::i;:::-;16484:2;16479:3;16475:12;16468:19;;16273:220;;;:::o;16499:366::-;16641:3;16662:67;16726:2;16721:3;16662:67;:::i;:::-;16655:74;;16738:93;16827:3;16738:93;:::i;:::-;16856:2;16851:3;16847:12;16840:19;;16645:220;;;:::o;16871:366::-;17013:3;17034:67;17098:2;17093:3;17034:67;:::i;:::-;17027:74;;17110:93;17199:3;17110:93;:::i;:::-;17228:2;17223:3;17219:12;17212:19;;17017:220;;;:::o;17243:366::-;17385:3;17406:67;17470:2;17465:3;17406:67;:::i;:::-;17399:74;;17482:93;17571:3;17482:93;:::i;:::-;17600:2;17595:3;17591:12;17584:19;;17389:220;;;:::o;17615:366::-;17757:3;17778:67;17842:2;17837:3;17778:67;:::i;:::-;17771:74;;17854:93;17943:3;17854:93;:::i;:::-;17972:2;17967:3;17963:12;17956:19;;17761:220;;;:::o;17987:366::-;18129:3;18150:67;18214:2;18209:3;18150:67;:::i;:::-;18143:74;;18226:93;18315:3;18226:93;:::i;:::-;18344:2;18339:3;18335:12;18328:19;;18133:220;;;:::o;18359:366::-;18501:3;18522:67;18586:2;18581:3;18522:67;:::i;:::-;18515:74;;18598:93;18687:3;18598:93;:::i;:::-;18716:2;18711:3;18707:12;18700:19;;18505:220;;;:::o;18731:366::-;18873:3;18894:67;18958:2;18953:3;18894:67;:::i;:::-;18887:74;;18970:93;19059:3;18970:93;:::i;:::-;19088:2;19083:3;19079:12;19072:19;;18877:220;;;:::o;19103:366::-;19245:3;19266:67;19330:2;19325:3;19266:67;:::i;:::-;19259:74;;19342:93;19431:3;19342:93;:::i;:::-;19460:2;19455:3;19451:12;19444:19;;19249:220;;;:::o;19475:108::-;19552:24;19570:5;19552:24;:::i;:::-;19547:3;19540:37;19530:53;;:::o;19589:118::-;19676:24;19694:5;19676:24;:::i;:::-;19671:3;19664:37;19654:53;;:::o;19713:222::-;19806:4;19844:2;19833:9;19829:18;19821:26;;19857:71;19925:1;19914:9;19910:17;19901:6;19857:71;:::i;:::-;19811:124;;;;:::o;19941:640::-;20136:4;20174:3;20163:9;20159:19;20151:27;;20188:71;20256:1;20245:9;20241:17;20232:6;20188:71;:::i;:::-;20269:72;20337:2;20326:9;20322:18;20313:6;20269:72;:::i;:::-;20351;20419:2;20408:9;20404:18;20395:6;20351:72;:::i;:::-;20470:9;20464:4;20460:20;20455:2;20444:9;20440:18;20433:48;20498:76;20569:4;20560:6;20498:76;:::i;:::-;20490:84;;20141:440;;;;;;;:::o;20587:332::-;20708:4;20746:2;20735:9;20731:18;20723:26;;20759:71;20827:1;20816:9;20812:17;20803:6;20759:71;:::i;:::-;20840:72;20908:2;20897:9;20893:18;20884:6;20840:72;:::i;:::-;20713:206;;;;;:::o;20925:373::-;21068:4;21106:2;21095:9;21091:18;21083:26;;21155:9;21149:4;21145:20;21141:1;21130:9;21126:17;21119:47;21183:108;21286:4;21277:6;21183:108;:::i;:::-;21175:116;;21073:225;;;;:::o;21304:210::-;21391:4;21429:2;21418:9;21414:18;21406:26;;21442:65;21504:1;21493:9;21489:17;21480:6;21442:65;:::i;:::-;21396:118;;;;:::o;21520:313::-;21633:4;21671:2;21660:9;21656:18;21648:26;;21720:9;21714:4;21710:20;21706:1;21695:9;21691:17;21684:47;21748:78;21821:4;21812:6;21748:78;:::i;:::-;21740:86;;21638:195;;;;:::o;21839:419::-;22005:4;22043:2;22032:9;22028:18;22020:26;;22092:9;22086:4;22082:20;22078:1;22067:9;22063:17;22056:47;22120:131;22246:4;22120:131;:::i;:::-;22112:139;;22010:248;;;:::o;22264:419::-;22430:4;22468:2;22457:9;22453:18;22445:26;;22517:9;22511:4;22507:20;22503:1;22492:9;22488:17;22481:47;22545:131;22671:4;22545:131;:::i;:::-;22537:139;;22435:248;;;:::o;22689:419::-;22855:4;22893:2;22882:9;22878:18;22870:26;;22942:9;22936:4;22932:20;22928:1;22917:9;22913:17;22906:47;22970:131;23096:4;22970:131;:::i;:::-;22962:139;;22860:248;;;:::o;23114:419::-;23280:4;23318:2;23307:9;23303:18;23295:26;;23367:9;23361:4;23357:20;23353:1;23342:9;23338:17;23331:47;23395:131;23521:4;23395:131;:::i;:::-;23387:139;;23285:248;;;:::o;23539:419::-;23705:4;23743:2;23732:9;23728:18;23720:26;;23792:9;23786:4;23782:20;23778:1;23767:9;23763:17;23756:47;23820:131;23946:4;23820:131;:::i;:::-;23812:139;;23710:248;;;:::o;23964:419::-;24130:4;24168:2;24157:9;24153:18;24145:26;;24217:9;24211:4;24207:20;24203:1;24192:9;24188:17;24181:47;24245:131;24371:4;24245:131;:::i;:::-;24237:139;;24135:248;;;:::o;24389:419::-;24555:4;24593:2;24582:9;24578:18;24570:26;;24642:9;24636:4;24632:20;24628:1;24617:9;24613:17;24606:47;24670:131;24796:4;24670:131;:::i;:::-;24662:139;;24560:248;;;:::o;24814:419::-;24980:4;25018:2;25007:9;25003:18;24995:26;;25067:9;25061:4;25057:20;25053:1;25042:9;25038:17;25031:47;25095:131;25221:4;25095:131;:::i;:::-;25087:139;;24985:248;;;:::o;25239:419::-;25405:4;25443:2;25432:9;25428:18;25420:26;;25492:9;25486:4;25482:20;25478:1;25467:9;25463:17;25456:47;25520:131;25646:4;25520:131;:::i;:::-;25512:139;;25410:248;;;:::o;25664:419::-;25830:4;25868:2;25857:9;25853:18;25845:26;;25917:9;25911:4;25907:20;25903:1;25892:9;25888:17;25881:47;25945:131;26071:4;25945:131;:::i;:::-;25937:139;;25835:248;;;:::o;26089:419::-;26255:4;26293:2;26282:9;26278:18;26270:26;;26342:9;26336:4;26332:20;26328:1;26317:9;26313:17;26306:47;26370:131;26496:4;26370:131;:::i;:::-;26362:139;;26260:248;;;:::o;26514:419::-;26680:4;26718:2;26707:9;26703:18;26695:26;;26767:9;26761:4;26757:20;26753:1;26742:9;26738:17;26731:47;26795:131;26921:4;26795:131;:::i;:::-;26787:139;;26685:248;;;:::o;26939:419::-;27105:4;27143:2;27132:9;27128:18;27120:26;;27192:9;27186:4;27182:20;27178:1;27167:9;27163:17;27156:47;27220:131;27346:4;27220:131;:::i;:::-;27212:139;;27110:248;;;:::o;27364:419::-;27530:4;27568:2;27557:9;27553:18;27545:26;;27617:9;27611:4;27607:20;27603:1;27592:9;27588:17;27581:47;27645:131;27771:4;27645:131;:::i;:::-;27637:139;;27535:248;;;:::o;27789:419::-;27955:4;27993:2;27982:9;27978:18;27970:26;;28042:9;28036:4;28032:20;28028:1;28017:9;28013:17;28006:47;28070:131;28196:4;28070:131;:::i;:::-;28062:139;;27960:248;;;:::o;28214:419::-;28380:4;28418:2;28407:9;28403:18;28395:26;;28467:9;28461:4;28457:20;28453:1;28442:9;28438:17;28431:47;28495:131;28621:4;28495:131;:::i;:::-;28487:139;;28385:248;;;:::o;28639:419::-;28805:4;28843:2;28832:9;28828:18;28820:26;;28892:9;28886:4;28882:20;28878:1;28867:9;28863:17;28856:47;28920:131;29046:4;28920:131;:::i;:::-;28912:139;;28810:248;;;:::o;29064:419::-;29230:4;29268:2;29257:9;29253:18;29245:26;;29317:9;29311:4;29307:20;29303:1;29292:9;29288:17;29281:47;29345:131;29471:4;29345:131;:::i;:::-;29337:139;;29235:248;;;:::o;29489:419::-;29655:4;29693:2;29682:9;29678:18;29670:26;;29742:9;29736:4;29732:20;29728:1;29717:9;29713:17;29706:47;29770:131;29896:4;29770:131;:::i;:::-;29762:139;;29660:248;;;:::o;29914:222::-;30007:4;30045:2;30034:9;30030:18;30022:26;;30058:71;30126:1;30115:9;30111:17;30102:6;30058:71;:::i;:::-;30012:124;;;;:::o;30142:129::-;30176:6;30203:20;;:::i;:::-;30193:30;;30232:33;30260:4;30252:6;30232:33;:::i;:::-;30183:88;;;:::o;30277:75::-;30310:6;30343:2;30337:9;30327:19;;30317:35;:::o;30358:311::-;30435:4;30525:18;30517:6;30514:30;30511:2;;;30547:18;;:::i;:::-;30511:2;30597:4;30589:6;30585:17;30577:25;;30657:4;30651;30647:15;30639:23;;30440:229;;;:::o;30675:321::-;30762:4;30852:18;30844:6;30841:30;30838:2;;;30874:18;;:::i;:::-;30838:2;30924:4;30916:6;30912:17;30904:25;;30984:4;30978;30974:15;30966:23;;30767:229;;;:::o;31002:307::-;31063:4;31153:18;31145:6;31142:30;31139:2;;;31175:18;;:::i;:::-;31139:2;31213:29;31235:6;31213:29;:::i;:::-;31205:37;;31297:4;31291;31287:15;31279:23;;31068:241;;;:::o;31315:308::-;31377:4;31467:18;31459:6;31456:30;31453:2;;;31489:18;;:::i;:::-;31453:2;31527:29;31549:6;31527:29;:::i;:::-;31519:37;;31611:4;31605;31601:15;31593:23;;31382:241;;;:::o;31629:132::-;31696:4;31719:3;31711:11;;31749:4;31744:3;31740:14;31732:22;;31701:60;;;:::o;31767:114::-;31834:6;31868:5;31862:12;31852:22;;31841:40;;;:::o;31887:98::-;31938:6;31972:5;31966:12;31956:22;;31945:40;;;:::o;31991:99::-;32043:6;32077:5;32071:12;32061:22;;32050:40;;;:::o;32096:113::-;32166:4;32198;32193:3;32189:14;32181:22;;32171:38;;;:::o;32215:184::-;32314:11;32348:6;32343:3;32336:19;32388:4;32383:3;32379:14;32364:29;;32326:73;;;;:::o;32405:168::-;32488:11;32522:6;32517:3;32510:19;32562:4;32557:3;32553:14;32538:29;;32500:73;;;;:::o;32579:169::-;32663:11;32697:6;32692:3;32685:19;32737:4;32732:3;32728:14;32713:29;;32675:73;;;;:::o;32754:305::-;32794:3;32813:20;32831:1;32813:20;:::i;:::-;32808:25;;32847:20;32865:1;32847:20;:::i;:::-;32842:25;;33001:1;32933:66;32929:74;32926:1;32923:81;32920:2;;;33007:18;;:::i;:::-;32920:2;33051:1;33048;33044:9;33037:16;;32798:261;;;;:::o;33065:191::-;33105:4;33125:20;33143:1;33125:20;:::i;:::-;33120:25;;33159:20;33177:1;33159:20;:::i;:::-;33154:25;;33198:1;33195;33192:8;33189:2;;;33203:18;;:::i;:::-;33189:2;33248:1;33245;33241:9;33233:17;;33110:146;;;;:::o;33262:96::-;33299:7;33328:24;33346:5;33328:24;:::i;:::-;33317:35;;33307:51;;;:::o;33364:90::-;33398:7;33441:5;33434:13;33427:21;33416:32;;33406:48;;;:::o;33460:149::-;33496:7;33536:66;33529:5;33525:78;33514:89;;33504:105;;;:::o;33615:110::-;33666:7;33695:24;33713:5;33695:24;:::i;:::-;33684:35;;33674:51;;;:::o;33731:126::-;33768:7;33808:42;33801:5;33797:54;33786:65;;33776:81;;;:::o;33863:77::-;33900:7;33929:5;33918:16;;33908:32;;;:::o;33946:154::-;34030:6;34025:3;34020;34007:30;34092:1;34083:6;34078:3;34074:16;34067:27;33997:103;;;:::o;34106:307::-;34174:1;34184:113;34198:6;34195:1;34192:13;34184:113;;;34283:1;34278:3;34274:11;34268:18;34264:1;34259:3;34255:11;34248:39;34220:2;34217:1;34213:10;34208:15;;34184:113;;;34315:6;34312:1;34309:13;34306:2;;;34395:1;34386:6;34381:3;34377:16;34370:27;34306:2;34155:258;;;;:::o;34419:320::-;34463:6;34500:1;34494:4;34490:12;34480:22;;34547:1;34541:4;34537:12;34568:18;34558:2;;34624:4;34616:6;34612:17;34602:27;;34558:2;34686;34678:6;34675:14;34655:18;34652:38;34649:2;;;34705:18;;:::i;:::-;34649:2;34470:269;;;;:::o;34745:281::-;34828:27;34850:4;34828:27;:::i;:::-;34820:6;34816:40;34958:6;34946:10;34943:22;34922:18;34910:10;34907:34;34904:62;34901:2;;;34969:18;;:::i;:::-;34901:2;35009:10;35005:2;34998:22;34788:238;;;:::o;35032:233::-;35071:3;35094:24;35112:5;35094:24;:::i;:::-;35085:33;;35140:66;35133:5;35130:77;35127:2;;;35210:18;;:::i;:::-;35127:2;35257:1;35250:5;35246:13;35239:20;;35075:190;;;:::o;35271:180::-;35319:77;35316:1;35309:88;35416:4;35413:1;35406:15;35440:4;35437:1;35430:15;35457:180;35505:77;35502:1;35495:88;35602:4;35599:1;35592:15;35626:4;35623:1;35616:15;35643:180;35691:77;35688:1;35681:88;35788:4;35785:1;35778:15;35812:4;35809:1;35802:15;35829:102;35870:6;35921:2;35917:7;35912:2;35905:5;35901:14;35897:28;35887:38;;35877:54;;;:::o;35937:232::-;36077:34;36073:1;36065:6;36061:14;36054:58;36146:15;36141:2;36133:6;36129:15;36122:40;36043:126;:::o;36175:230::-;36315:34;36311:1;36303:6;36299:14;36292:58;36384:13;36379:2;36371:6;36367:15;36360:38;36281:124;:::o;36411:237::-;36551:34;36547:1;36539:6;36535:14;36528:58;36620:20;36615:2;36607:6;36603:15;36596:45;36517:131;:::o;36654:225::-;36794:34;36790:1;36782:6;36778:14;36771:58;36863:8;36858:2;36850:6;36846:15;36839:33;36760:119;:::o;36885:165::-;37025:17;37021:1;37013:6;37009:14;37002:41;36991:59;:::o;37056:224::-;37196:34;37192:1;37184:6;37180:14;37173:58;37265:7;37260:2;37252:6;37248:15;37241:32;37162:118;:::o;37286:178::-;37426:30;37422:1;37414:6;37410:14;37403:54;37392:72;:::o;37470:223::-;37610:34;37606:1;37598:6;37594:14;37587:58;37679:6;37674:2;37666:6;37662:15;37655:31;37576:117;:::o;37699:175::-;37839:27;37835:1;37827:6;37823:14;37816:51;37805:69;:::o;37880:228::-;38020:34;38016:1;38008:6;38004:14;37997:58;38089:11;38084:2;38076:6;38072:15;38065:36;37986:122;:::o;38114:182::-;38254:34;38250:1;38242:6;38238:14;38231:58;38220:76;:::o;38302:182::-;38442:34;38438:1;38430:6;38426:14;38419:58;38408:76;:::o;38490:174::-;38630:26;38626:1;38618:6;38614:14;38607:50;38596:68;:::o;38670:220::-;38810:34;38806:1;38798:6;38794:14;38787:58;38879:3;38874:2;38866:6;38862:15;38855:28;38776:114;:::o;38896:174::-;39036:26;39032:1;39024:6;39020:14;39013:50;39002:68;:::o;39076:165::-;39216:17;39212:1;39204:6;39200:14;39193:41;39182:59;:::o;39247:248::-;39387:34;39383:1;39375:6;39371:14;39364:58;39456:31;39451:2;39443:6;39439:15;39432:56;39353:142;:::o;39501:231::-;39641:34;39637:1;39629:6;39625:14;39618:58;39710:14;39705:2;39697:6;39693:15;39686:39;39607:125;:::o;39738:240::-;39878:34;39874:1;39866:6;39862:14;39855:58;39947:23;39942:2;39934:6;39930:15;39923:48;39844:134;:::o;39984:122::-;40057:24;40075:5;40057:24;:::i;:::-;40050:5;40047:35;40037:2;;40096:1;40093;40086:12;40037:2;40027:79;:::o;40112:116::-;40182:21;40197:5;40182:21;:::i;:::-;40175:5;40172:32;40162:2;;40218:1;40215;40208:12;40162:2;40152:76;:::o;40234:120::-;40306:23;40323:5;40306:23;:::i;:::-;40299:5;40296:34;40286:2;;40344:1;40341;40334:12;40286:2;40276:78;:::o;40360:150::-;40447:38;40479:5;40447:38;:::i;:::-;40440:5;40437:49;40427:2;;40500:1;40497;40490:12;40427:2;40417:93;:::o;40516:122::-;40589:24;40607:5;40589:24;:::i;:::-;40582:5;40579:35;40569:2;;40628:1;40625;40618:12;40569:2;40559:79;:::o
Swarm Source
ipfs://451b1010f1a595a0b884bb5ceaf4dc00ee629a36e3032e635a799a8eaeeaad04