ERC-20
Overview
Max Total Supply
996 RATS
Holders
273
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract (WITH 18 Decimals)
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
Rats
Compiler Version
v0.6.12+commit.27d51765
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2021-02-09 */ // SPDX-License-Identifier: UNLICENSED AND MIT // File: @openzeppelin/contracts/GSN/Context.sol pragma solidity ^0.6.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 GSN 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 payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } } // File: @openzeppelin/contracts/access/Ownable.sol pragma solidity ^0.6.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ 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 () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { 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 { emit OwnershipTransferred(_owner, address(0)); _owner = 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"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } } // File: @openzeppelin/contracts/token/ERC20/IERC20.sol pragma solidity ^0.6.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @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 `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, 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 `sender` to `recipient` 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 sender, address recipient, uint256 amount) external returns (bool); /** * @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); } // File: @openzeppelin/contracts/math/SafeMath.sol pragma solidity ^0.6.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return sub(a, b, "SafeMath: subtraction overflow"); } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); uint256 c = a - b; return c; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) { return 0; } uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers. Reverts on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return div(a, b, "SafeMath: division by zero"); } /** * @dev Returns the integer division of two unsigned integers. Reverts with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); uint256 c = a / b; // assert(a == b * c + a % b); // There is no case in which this doesn't hold return c; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return mod(a, b, "SafeMath: modulo by zero"); } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * Reverts with custom message when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b != 0, errorMessage); return a % b; } } // File: @openzeppelin/contracts/utils/Address.sol pragma solidity ^0.6.2; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies in extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return _functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); return _functionCallWithValue(target, data, value, errorMessage); } function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) { require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: weiValue }(data); if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File: @openzeppelin/contracts/token/ERC20/ERC20.sol pragma solidity ^0.6.0; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { using SafeMath for uint256; using Address for address; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory name, string memory symbol) public { _name = name; _symbol = symbol; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}; * * Requirements: * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal { _decimals = decimals_; } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } } // File: @openzeppelin/contracts/token/ERC20/ERC20Burnable.sol pragma solidity ^0.6.0; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance"); _approve(account, _msgSender(), decreasedAllowance); _burn(account, amount); } } // File: @openzeppelin/contracts/introspection/IERC165.sol pragma solidity ^0.6.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/introspection/ERC165.sol pragma solidity ^0.6.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts may inherit from this and call {_registerInterface} to declare * their support of an interface. */ contract ERC165 is IERC165 { /* * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7 */ bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7; /** * @dev Mapping of interface ids to whether or not it's supported. */ mapping(bytes4 => bool) private _supportedInterfaces; constructor () internal { // Derived contracts need only register support for their own interfaces, // we register support for ERC165 itself here _registerInterface(_INTERFACE_ID_ERC165); } /** * @dev See {IERC165-supportsInterface}. * * Time complexity O(1), guaranteed to always use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) public view override returns (bool) { return _supportedInterfaces[interfaceId]; } /** * @dev Registers the contract as an implementer of the interface defined by * `interfaceId`. Support of the actual ERC165 interface is automatic and * registering its interface id is not required. * * See {IERC165-supportsInterface}. * * Requirements: * * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`). */ function _registerInterface(bytes4 interfaceId) internal virtual { require(interfaceId != 0xffffffff, "ERC165: invalid interface id"); _supportedInterfaces[interfaceId] = true; } } // File: @openzeppelin/contracts/token/ERC721/IERC721.sol pragma solidity ^0.6.2; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom(address from, address to, uint256 tokenId) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external; } // File: @openzeppelin/contracts/token/ERC1155/IERC1155.sol pragma solidity ^0.6.2; /** * @dev Required interface of an ERC1155 compliant contract, as defined in the * https://eips.ethereum.org/EIPS/eip-1155[EIP]. * * _Available since v3.1._ */ interface IERC1155 is IERC165 { /** * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`. */ event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value); /** * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all * transfers. */ event TransferBatch(address indexed operator, address indexed from, address indexed to, uint256[] ids, uint256[] values); /** * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to * `approved`. */ event ApprovalForAll(address indexed account, address indexed operator, bool approved); /** * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI. * * If an {URI} event was emitted for `id`, the standard * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value * returned by {IERC1155MetadataURI-uri}. */ event URI(string value, uint256 indexed id); /** * @dev Returns the amount of tokens of token type `id` owned by `account`. * * Requirements: * * - `account` cannot be the zero address. */ function balanceOf(address account, uint256 id) external view returns (uint256); /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}. * * Requirements: * * - `accounts` and `ids` must have the same length. */ function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids) external view returns (uint256[] memory); /** * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`, * * Emits an {ApprovalForAll} event. * * Requirements: * * - `operator` cannot be the caller. */ function setApprovalForAll(address operator, bool approved) external; /** * @dev Returns true if `operator` is approved to transfer ``account``'s tokens. * * See {setApprovalForAll}. */ function isApprovedForAll(address account, address operator) external view returns (bool); /** * @dev Transfers `amount` tokens of token type `id` from `from` to `to`. * * Emits a {TransferSingle} event. * * Requirements: * * - `to` cannot be the zero address. * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}. * - `from` must have a balance of tokens of type `id` of at least `amount`. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the * acceptance magic value. */ function safeTransferFrom(address from, address to, uint256 id, uint256 amount, bytes calldata data) external; /** * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}. * * Emits a {TransferBatch} event. * * Requirements: * * - `ids` and `amounts` must have the same length. * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the * acceptance magic value. */ function safeBatchTransferFrom(address from, address to, uint256[] calldata ids, uint256[] calldata amounts, bytes calldata data) external; } // File: @openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol pragma solidity ^0.6.0; /** * _Available since v3.1._ */ interface IERC1155Receiver is IERC165 { /** @dev Handles the receipt of a single ERC1155 token type. This function is called at the end of a `safeTransferFrom` after the balance has been updated. To accept the transfer, this must return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` (i.e. 0xf23a6e61, or its own function selector). @param operator The address which initiated the transfer (i.e. msg.sender) @param from The address which previously owned the token @param id The ID of the token being transferred @param value The amount of tokens being transferred @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed */ function onERC1155Received( address operator, address from, uint256 id, uint256 value, bytes calldata data ) external returns(bytes4); /** @dev Handles the receipt of a multiple ERC1155 token types. This function is called at the end of a `safeBatchTransferFrom` after the balances have been updated. To accept the transfer(s), this must return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` (i.e. 0xbc197c81, or its own function selector). @param operator The address which initiated the batch transfer (i.e. msg.sender) @param from The address which previously owned the token @param ids An array containing ids of each token being transferred (order and length must match values array) @param values An array containing amounts of each token being transferred (order and length must match ids array) @param data Additional data with no specified format @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed */ function onERC1155BatchReceived( address operator, address from, uint256[] calldata ids, uint256[] calldata values, bytes calldata data ) external returns(bytes4); } // File: @openzeppelin/contracts/token/ERC1155/ERC1155Receiver.sol pragma solidity ^0.6.0; /** * @dev _Available since v3.1._ */ abstract contract ERC1155Receiver is ERC165, IERC1155Receiver { constructor() public { _registerInterface( ERC1155Receiver(0).onERC1155Received.selector ^ ERC1155Receiver(0).onERC1155BatchReceived.selector ); } } // File: @openzeppelin/contracts/utils/EnumerableSet.sol pragma solidity ^0.6.0; /** * @dev Library for managing * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive * types. * * Sets have the following properties: * * - Elements are added, removed, and checked for existence in constant time * (O(1)). * - Elements are enumerated in O(n). No guarantees are made on the ordering. * * ``` * contract Example { * // Add the library methods * using EnumerableSet for EnumerableSet.AddressSet; * * // Declare a set state variable * EnumerableSet.AddressSet private mySet; * } * ``` * * As of v3.0.0, only sets of type `address` (`AddressSet`) and `uint256` * (`UintSet`) are supported. */ library EnumerableSet { // To implement this library for multiple types with as little code // repetition as possible, we write it in terms of a generic Set type with // bytes32 values. // The Set implementation uses private functions, and user-facing // implementations (such as AddressSet) are just wrappers around the // underlying Set. // This means that we can only create new EnumerableSets for types that fit // in bytes32. struct Set { // Storage of set values bytes32[] _values; // Position of the value in the `values` array, plus 1 because index 0 // means a value is not in the set. mapping (bytes32 => uint256) _indexes; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function _add(Set storage set, bytes32 value) private returns (bool) { if (!_contains(set, value)) { set._values.push(value); // The value is stored at length-1, but we add 1 to all indexes // and use 0 as a sentinel value set._indexes[value] = set._values.length; return true; } else { return false; } } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function _remove(Set storage set, bytes32 value) private returns (bool) { // We read and store the value's index to prevent multiple reads from the same storage slot uint256 valueIndex = set._indexes[value]; if (valueIndex != 0) { // Equivalent to contains(set, value) // To delete an element from the _values array in O(1), we swap the element to delete with the last one in // the array, and then remove the last element (sometimes called as 'swap and pop'). // This modifies the order of the array, as noted in {at}. uint256 toDeleteIndex = valueIndex - 1; uint256 lastIndex = set._values.length - 1; // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement. bytes32 lastvalue = set._values[lastIndex]; // Move the last value to the index where the value to delete is set._values[toDeleteIndex] = lastvalue; // Update the index for the moved value set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based // Delete the slot where the moved value was stored set._values.pop(); // Delete the index for the deleted slot delete set._indexes[value]; return true; } else { return false; } } /** * @dev Returns true if the value is in the set. O(1). */ function _contains(Set storage set, bytes32 value) private view returns (bool) { return set._indexes[value] != 0; } /** * @dev Returns the number of values on the set. O(1). */ function _length(Set storage set) private view returns (uint256) { return set._values.length; } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function _at(Set storage set, uint256 index) private view returns (bytes32) { require(set._values.length > index, "EnumerableSet: index out of bounds"); return set._values[index]; } // AddressSet struct AddressSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(AddressSet storage set, address value) internal returns (bool) { return _add(set._inner, bytes32(uint256(value))); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(AddressSet storage set, address value) internal returns (bool) { return _remove(set._inner, bytes32(uint256(value))); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(AddressSet storage set, address value) internal view returns (bool) { return _contains(set._inner, bytes32(uint256(value))); } /** * @dev Returns the number of values in the set. O(1). */ function length(AddressSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(AddressSet storage set, uint256 index) internal view returns (address) { return address(uint256(_at(set._inner, index))); } // UintSet struct UintSet { Set _inner; } /** * @dev Add a value to a set. O(1). * * Returns true if the value was added to the set, that is if it was not * already present. */ function add(UintSet storage set, uint256 value) internal returns (bool) { return _add(set._inner, bytes32(value)); } /** * @dev Removes a value from a set. O(1). * * Returns true if the value was removed from the set, that is if it was * present. */ function remove(UintSet storage set, uint256 value) internal returns (bool) { return _remove(set._inner, bytes32(value)); } /** * @dev Returns true if the value is in the set. O(1). */ function contains(UintSet storage set, uint256 value) internal view returns (bool) { return _contains(set._inner, bytes32(value)); } /** * @dev Returns the number of values on the set. O(1). */ function length(UintSet storage set) internal view returns (uint256) { return _length(set._inner); } /** * @dev Returns the value stored at position `index` in the set. O(1). * * Note that there are no guarantees on the ordering of values inside the * array, and it may change when more values are added or removed. * * Requirements: * * - `index` must be strictly less than {length}. */ function at(UintSet storage set, uint256 index) internal view returns (uint256) { return uint256(_at(set._inner, index)); } } // File: contracts/Rats.sol pragma solidity ^0.6.0; pragma experimental ABIEncoderV2; contract Rats is ERC20, ERC20Burnable, ERC165, Ownable { using EnumerableSet for EnumerableSet.AddressSet; bool public allowEmergencyAccess; address payable public donationAddress; EnumerableSet.AddressSet private allowedErc721Contracts; EnumerableSet.AddressSet private allowedErc1155Contracts; bytes4 immutable onErc721SuccessfulResult = bytes4(keccak256("onERC721Received(address,address,uint256,bytes)")); bytes4 immutable onErc1155SuccessfulResult = bytes4( keccak256( "onERC1155Received(address,address,uint256,uint256,bytes)" ) ); event DepositedToken(address from); event DepositedERC721(address from, address tokenAddress, uint256 tokenId); event DepositedERC1155( address from, address tokenAddress, uint256 tokenId, uint256 amount ); event WithdrewToken(address from); event WithdrewERC721(address from, address tokenAddress, uint256 tokenId); event WithdrewERC1155( address from, address tokenAddress, uint256 tokenId, uint256 amount ); constructor() public ERC20("RATS", "RATS") ERC20Burnable() Ownable() { allowEmergencyAccess = true; donationAddress = (payable(owner())); // from ERC1155Receiver.sol _registerInterface( ERC1155Receiver(0).onERC1155Received.selector ^ ERC1155Receiver(0).onERC1155BatchReceived.selector ); } function revokeEmergencyAccess() public onlyOwner { allowEmergencyAccess = false; } function changeDonationAddress(address payable newAddress) public onlyOwner { donationAddress = newAddress; } modifier onlyEmergencyAccess() { require(msg.sender == owner(), "must be owner"); require(allowEmergencyAccess, "emergency access not allowed"); _; } // ---- receive callbacks ---- function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4) { address receivingErc721ContractAddress = msg.sender; IERC721 receivingErc721Contract = IERC721(receivingErc721ContractAddress); // ensure address is whitelisted require( allowedErc721Contracts.contains(receivingErc721ContractAddress), "contract not whitelisted" ); // ensure we have the nft require( receivingErc721Contract.ownerOf(tokenId) == address(this), "dont own erc721" ); // emit event emit DepositedERC721(from, receivingErc721ContractAddress, tokenId); // take action _giveTokenOrWithdrawArt(from, data); return onErc721SuccessfulResult; } function onERC1155Received( address operator, address from, uint256 tokenId, uint256 amountTokens, bytes calldata data ) external returns (bytes4) { address receivingErc1155ContractAddress = msg.sender; IERC1155 receivingErc1155Contract = IERC1155(receivingErc1155ContractAddress); // ensure address is whitelisted require( allowedErc1155Contracts.contains(receivingErc1155ContractAddress), "contract not whitelisted" ); // ensure we have the nft and didn't have prior require(amountTokens > 0, "must have non-zero amountTokens"); uint256 ourCurrentBalance = receivingErc1155Contract.balanceOf(address(this), tokenId); require(ourCurrentBalance == amountTokens, "Already had ERC1155"); // emit event emit DepositedERC1155( from, receivingErc1155ContractAddress, tokenId, amountTokens ); // take action _giveTokenOrWithdrawArt(from, data); return onErc1155SuccessfulResult; } function swapTokensForERC721Art( address contractAddressToSend, uint256 tokenIdToSend ) external payable { // burn erc20 from user emit DepositedToken(msg.sender); _burn(msg.sender, 1 ether); // send art _sendERC721Art(contractAddressToSend, tokenIdToSend, msg.sender); } function swapTokensForERC1155Art( address contractAddressToSend, uint256 tokenIdToSend ) external payable { // burn erc20 from user emit DepositedToken(msg.sender); _burn(msg.sender, 1 ether); // send art _sendERC1155Art(contractAddressToSend, tokenIdToSend, msg.sender); } function withdrawDonations() public { Address.sendValue(donationAddress, address(this).balance); } function maxSupply() public pure virtual returns (uint256) { return 1000 ether; } function maxTokensCreated() public view returns (bool) { return totalSupply() >= maxSupply(); } function _sendERC721Art( address contractAddressToSend, uint256 tokenIdToSend, address recipient ) private { IERC721 sendingErc721Contract = IERC721(contractAddressToSend); sendingErc721Contract.safeTransferFrom( address(this), recipient, tokenIdToSend ); emit WithdrewERC721(recipient, contractAddressToSend, tokenIdToSend); } function _sendERC1155Art( address contractAddressToSend, uint256 tokenIdToSend, address recipient ) private { IERC1155 sendingErc1155Contract = IERC1155(contractAddressToSend); uint256 balance = sendingErc1155Contract.balanceOf(address(this), tokenIdToSend); require(balance > 0, "doesnt hold any balance"); sendingErc1155Contract.safeTransferFrom( address(this), recipient, tokenIdToSend, balance, "" ); emit WithdrewERC1155( recipient, contractAddressToSend, tokenIdToSend, balance ); } function _giveTokenOrWithdrawArt(address from, bytes calldata data) private { if (data.length == 0) { // send tokens if (maxTokensCreated()) { revert("Max tokens created"); } _mint(from, 1 ether); emit WithdrewToken(from); } else { // do swap ( address contractAddressToSend, uint256 tokenIdToSend, bool isErc1155 ) = abi.decode(data, (address, uint256, bool)); if (isErc1155) { _sendERC1155Art(contractAddressToSend, tokenIdToSend, from); } else { _sendERC721Art(contractAddressToSend, tokenIdToSend, from); } } } // ------ allowedContracts fns ------- function getAllowedContractsLength(bool isErc721) public view returns (uint256) { EnumerableSet.AddressSet storage allowedAddresses = isErc721 ? allowedErc721Contracts : allowedErc1155Contracts; return allowedAddresses.length(); } function getAllowedContracts( bool isErc721, uint256 start, uint256 end ) public view returns (address[] memory) { EnumerableSet.AddressSet storage allowedAddresses = isErc721 ? allowedErc721Contracts : allowedErc1155Contracts; address[] memory re = new address[](end - start); for (uint256 i = start; i < end; i++) { re[i - start] = allowedAddresses.at(i); } return re; } function addAllowedContracts( bool isErc721, address[] memory contractAddresses ) public onlyOwner { EnumerableSet.AddressSet storage allowedAddresses = isErc721 ? allowedErc721Contracts : allowedErc1155Contracts; for (uint256 i = 0; i < contractAddresses.length; ++i) { allowedAddresses.add(contractAddresses[i]); } } // ----- emergency functions ------ function emergencyRemoveAllowedContracts( bool isErc721, address[] memory contractAddresses ) public onlyEmergencyAccess { EnumerableSet.AddressSet storage allowedAddresses = isErc721 ? allowedErc721Contracts : allowedErc1155Contracts; for (uint256 i = 0; i < contractAddresses.length; ++i) { allowedAddresses.remove(contractAddresses[i]); } } function emergencyMint(address account, uint256 amount) public onlyEmergencyAccess { _mint(account, amount); } function emergencyBurn(address account, uint256 amount) public onlyEmergencyAccess { _burn(account, amount); } function emergencyExecute( address targetAddress, bytes calldata targetCallData ) public onlyEmergencyAccess returns (bool) { (bool success, ) = targetAddress.call(targetCallData); return success; } }
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":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"DepositedERC1155","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"DepositedERC721","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"}],"name":"DepositedToken","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":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"WithdrewERC1155","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"tokenAddress","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"WithdrewERC721","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"}],"name":"WithdrewToken","type":"event"},{"inputs":[{"internalType":"bool","name":"isErc721","type":"bool"},{"internalType":"address[]","name":"contractAddresses","type":"address[]"}],"name":"addAllowedContracts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"allowEmergencyAccess","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"newAddress","type":"address"}],"name":"changeDonationAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"donationAddress","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"emergencyBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"targetAddress","type":"address"},{"internalType":"bytes","name":"targetCallData","type":"bytes"}],"name":"emergencyExecute","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"emergencyMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"isErc721","type":"bool"},{"internalType":"address[]","name":"contractAddresses","type":"address[]"}],"name":"emergencyRemoveAllowedContracts","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"isErc721","type":"bool"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"end","type":"uint256"}],"name":"getAllowedContracts","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"isErc721","type":"bool"}],"name":"getAllowedContractsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"maxTokensCreated","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"amountTokens","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revokeEmergencyAccess","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":[{"internalType":"address","name":"contractAddressToSend","type":"address"},{"internalType":"uint256","name":"tokenIdToSend","type":"uint256"}],"name":"swapTokensForERC1155Art","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddressToSend","type":"address"},{"internalType":"uint256","name":"tokenIdToSend","type":"uint256"}],"name":"swapTokensForERC721Art","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"symbol","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":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawDonations","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
51992:9450:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31564:142;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56479:348;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;19733:83;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21839:169;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54034:905;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20808:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52111:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22482:321;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20660:83;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23212:218;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56125:346;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;59517:480;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;29026:91;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60005:399;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60885:147;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53655:146;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;20971:119;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2762:148;;;;;;;;;;;;;:::i;:::-;;29436:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2120:79;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19935:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53550:97;;;;;;;;;;;;;:::i;:::-;;61195:244;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23933:269;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21303:175;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;59211:298;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57058:109;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61040:147;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56835:112;;;;;;;;;;;;;:::i;:::-;;56955:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;21541:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52150:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54947:1170;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3065:244;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;60453:424;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;31564:142;31641:4;31665:20;:33;31686:11;31665:33;;;;;;;;;;;;;;;;;;;;;;;;;;;31658:40;;31564:142;;;:::o;56479:348::-;56657:26;56672:10;56657:26;;;;;;:::i;:::-;;;;;;;;56694;56700:10;56712:7;56694:5;:26::i;:::-;56754:65;56770:21;56793:13;56808:10;56754:15;:65::i;:::-;56479:348;;:::o;19733:83::-;19770:13;19803:5;19796:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19733:83;:::o;21839:169::-;21922:4;21939:39;21948:12;:10;:12::i;:::-;21962:7;21971:6;21939:8;:39::i;:::-;21996:4;21989:11;;21839:169;;;;:::o;54034:905::-;54191:6;54210:38;54251:10;54210:51;;54272:31;54327:30;54272:86;;54435:63;54467:30;54435:22;:31;;:63;;;;:::i;:::-;54413:137;;;;;;;;;;;;:::i;:::-;;;;;;;;;54670:4;54618:57;;:23;:31;;;54650:7;54618:40;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:57;;;54596:122;;;;;;;;;;;;:::i;:::-;;;;;;;;;54757:62;54773:4;54779:30;54811:7;54757:62;;;;;;;;:::i;:::-;;;;;;;;54854:35;54878:4;54884;;54854:23;:35::i;:::-;54907:24;54900:31;;;;54034:905;;;;;;;:::o;20808:100::-;20861:7;20888:12;;20881:19;;20808:100;:::o;52111:32::-;;;;;;;;;;;;;:::o;22482:321::-;22588:4;22605:36;22615:6;22623:9;22634:6;22605:9;:36::i;:::-;22652:121;22661:6;22669:12;:10;:12::i;:::-;22683:89;22721:6;22683:89;;;;;;;;;;;;;;;;;:11;:19;22695:6;22683:19;;;;;;;;;;;;;;;:33;22703:12;:10;:12::i;:::-;22683:33;;;;;;;;;;;;;;;;:37;;:89;;;;;:::i;:::-;22652:8;:121::i;:::-;22791:4;22784:11;;22482:321;;;;;:::o;20660:83::-;20701:5;20726:9;;;;;;;;;;;20719:16;;20660:83;:::o;23212:218::-;23300:4;23317:83;23326:12;:10;:12::i;:::-;23340:7;23349:50;23388:10;23349:11;:25;23361:12;:10;:12::i;:::-;23349:25;;;;;;;;;;;;;;;:34;23375:7;23349:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;23317:8;:83::i;:::-;23418:4;23411:11;;23212:218;;;;:::o;56125:346::-;56302:26;56317:10;56302:26;;;;;;:::i;:::-;;;;;;;;56339;56345:10;56357:7;56339:5;:26::i;:::-;56399:64;56414:21;56437:13;56452:10;56399:14;:64::i;:::-;56125:346;;:::o;59517:480::-;59644:16;59673:49;59738:8;:59;;59774:23;59738:59;;;59749:22;59738:59;59673:124;;59808:19;59850:5;59844:3;:11;59830:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59808:48;;59872:9;59884:5;59872:17;;59867:103;59895:3;59891:1;:7;59867:103;;;59936:22;59956:1;59936:16;:19;;:22;;;;:::i;:::-;59920:2;59927:5;59923:1;:9;59920:13;;;;;;;;;;;;;:38;;;;;;;;;;;59900:3;;;;;;;59867:103;;;;59987:2;59980:9;;;;59517:480;;;;;:::o;29026:91::-;29082:27;29088:12;:10;:12::i;:::-;29102:6;29082:5;:27::i;:::-;29026:91;:::o;60005:399::-;2342:12;:10;:12::i;:::-;2332:22;;:6;;;;;;;;;;;:22;;;2324:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;60138:49:::1;60203:8;:59;;60239:23;60203:59;;;60214:22;60203:59;60138:124;;60278:9;60273:124;60297:17;:24;60293:1;:28;60273:124;;;60343:42;60364:17;60382:1;60364:20;;;;;;;;;;;;;;60343:16;:20;;:42;;;;:::i;:::-;;60323:3;;;;;60273:124;;;;2402:1;60005:399:::0;;:::o;60885:147::-;53873:7;:5;:7::i;:::-;53859:21;;:10;:21;;;53851:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;53917:20;;;;;;;;;;;53909:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;61002:22:::1;61008:7;61017:6;61002:5;:22::i;:::-;60885:147:::0;;:::o;53655:146::-;2342:12;:10;:12::i;:::-;2332:22;;:6;;;;;;;;;;;:22;;;2324:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;53783:10:::1;53765:15;;:28;;;;;;;;;;;;;;;;;;53655:146:::0;:::o;20971:119::-;21037:7;21064:9;:18;21074:7;21064:18;;;;;;;;;;;;;;;;21057:25;;20971:119;;;:::o;2762:148::-;2342:12;:10;:12::i;:::-;2332:22;;:6;;;;;;;;;;;:22;;;2324:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;2869:1:::1;2832:40;;2853:6;;;;;;;;;;;2832:40;;;;;;;;;;;;2900:1;2883:6;;:19;;;;;;;;;;;;;;;;;;2762:148::o:0;29436:295::-;29513:26;29542:84;29579:6;29542:84;;;;;;;;;;;;;;;;;:32;29552:7;29561:12;:10;:12::i;:::-;29542:9;:32::i;:::-;:36;;:84;;;;;:::i;:::-;29513:113;;29639:51;29648:7;29657:12;:10;:12::i;:::-;29671:18;29639:8;:51::i;:::-;29701:22;29707:7;29716:6;29701:5;:22::i;:::-;29436:295;;;:::o;2120:79::-;2158:7;2185:6;;;;;;;;;;;2178:13;;2120:79;:::o;19935:87::-;19974:13;20007:7;20000:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19935:87;:::o;53550:97::-;2342:12;:10;:12::i;:::-;2332:22;;:6;;;;;;;;;;;:22;;;2324:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;53634:5:::1;53611:20;;:28;;;;;;;;;;;;;;;;;;53550:97::o:0;61195:244::-;61336:4;53873:7;:5;:7::i;:::-;53859:21;;:10;:21;;;53851:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;53917:20;;;;;;;;;;;53909:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;61354:12:::1;61372:13;:18;;61391:14;;61372:34;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61353:53;;;61424:7;61417:14;;;61195:244:::0;;;;;:::o;23933:269::-;24026:4;24043:129;24052:12;:10;:12::i;:::-;24066:7;24075:96;24114:15;24075:96;;;;;;;;;;;;;;;;;:11;:25;24087:12;:10;:12::i;:::-;24075:25;;;;;;;;;;;;;;;:34;24101:7;24075:34;;;;;;;;;;;;;;;;:38;;:96;;;;;:::i;:::-;24043:8;:129::i;:::-;24190:4;24183:11;;23933:269;;;;:::o;21303:175::-;21389:4;21406:42;21416:12;:10;:12::i;:::-;21430:9;21441:6;21406:9;:42::i;:::-;21466:4;21459:11;;21303:175;;;;:::o;59211:298::-;59309:7;59334:49;59399:8;:59;;59435:23;59399:59;;;59410:22;59399:59;59334:124;;59476:25;:16;:23;:25::i;:::-;59469:32;;;59211:298;;;:::o;57058:109::-;57107:4;57148:11;:9;:11::i;:::-;57131:13;:11;:13::i;:::-;:28;;57124:35;;57058:109;:::o;61040:147::-;53873:7;:5;:7::i;:::-;53859:21;;:10;:21;;;53851:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;53917:20;;;;;;;;;;;53909:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;61157:22:::1;61163:7;61172:6;61157:5;:22::i;:::-;61040:147:::0;;:::o;56835:112::-;56882:57;56900:15;;;;;;;;;;;56917:21;56882:17;:57::i;:::-;56835:112::o;56955:95::-;57005:7;57032:10;57025:17;;56955:95;:::o;21541:151::-;21630:7;21657:11;:18;21669:5;21657:18;;;;;;;;;;;;;;;:27;21676:7;21657:27;;;;;;;;;;;;;;;;21650:34;;21541:151;;;;:::o;52150:38::-;;;;;;;;;;;;;:::o;54947:1170::-;55136:6;55155:39;55197:10;55155:52;;55218:33;55276:31;55218:90;;55383:65;55416:31;55383:23;:32;;:65;;;;:::i;:::-;55361:139;;;;;;;;;;;;:::i;:::-;;;;;;;;;55591:1;55576:12;:16;55568:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;55639:25;55680:24;:34;;;55723:4;55730:7;55680:58;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55639:99;;55778:12;55757:17;:33;55749:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;55855:141;55886:4;55905:31;55951:7;55973:12;55855:141;;;;;;;;;:::i;:::-;;;;;;;;56031:35;56055:4;56061;;56031:23;:35::i;:::-;56084:25;56077:32;;;;;54947:1170;;;;;;;;:::o;3065:244::-;2342:12;:10;:12::i;:::-;2332:22;;:6;;;;;;;;;;;:22;;;2324:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;3174:1:::1;3154:22;;:8;:22;;;;3146:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;3264:8;3235:38;;3256:6;;;;;;;;;;;3235:38;;;;;;;;;;;;3293:8;3284:6;;:17;;;;;;;;;;;;;;;;;;3065:244:::0;:::o;60453:424::-;53873:7;:5;:7::i;:::-;53859:21;;:10;:21;;;53851:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;53917:20;;;;;;;;;;;53909:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;60608:49:::1;60673:8;:59;;60709:23;60673:59;;;60684:22;60673:59;60608:124;;60748:9;60743:127;60767:17;:24;60763:1;:28;60743:127;;;60813:45;60837:17;60855:1;60837:20;;;;;;;;;;;;;;60813:16;:23;;:45;;;;:::i;:::-;;60793:3;;;;;60743:127;;;;53981:1;60453:424:::0;;:::o;26222:418::-;26325:1;26306:21;;:7;:21;;;;26298:67;;;;;;;;;;;;:::i;:::-;;;;;;;;;26378:49;26399:7;26416:1;26420:6;26378:20;:49::i;:::-;26461:68;26484:6;26461:68;;;;;;;;;;;;;;;;;:9;:18;26471:7;26461:18;;;;;;;;;;;;;;;;:22;;:68;;;;;:::i;:::-;26440:9;:18;26450:7;26440:18;;;;;;;;;;;;;;;:89;;;;26555:24;26572:6;26555:12;;:16;;:24;;;;:::i;:::-;26540:12;:39;;;;26621:1;26595:37;;26604:7;26595:37;;;26625:6;26595:37;;;;;;:::i;:::-;;;;;;;;26222:418;;:::o;57624:722::-;57775:31;57818:21;57775:65;;57851:15;57882:22;:32;;;57923:4;57930:13;57882:62;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57851:93;;57973:1;57963:7;:11;57955:47;;;;;;;;;;;;:::i;:::-;;;;;;;;;58015:22;:39;;;58077:4;58097:9;58121:13;58149:7;58015:169;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58202:136;58232:9;58256:21;58292:13;58320:7;58202:136;;;;;;;;;:::i;:::-;;;;;;;;57624:722;;;;;:::o;674:106::-;727:15;762:10;755:17;;674:106;:::o;27078:346::-;27197:1;27180:19;;:5;:19;;;;27172:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;27278:1;27259:21;;:7;:21;;;;27251:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;27362:6;27332:11;:18;27344:5;27332:18;;;;;;;;;;;;;;;:27;27351:7;27332:27;;;;;;;;;;;;;;;:36;;;;27400:7;27384:32;;27393:5;27384:32;;;27409:6;27384:32;;;;;;:::i;:::-;;;;;;;;27078:346;;;:::o;49415:158::-;49495:4;49519:46;49529:3;:10;;49557:5;49549:14;;49541:23;;49519:9;:46::i;:::-;49512:53;;49415:158;;;;:::o;58354:805::-;58474:1;58459:4;;:11;;:16;58455:697;;;58524:18;:16;:18::i;:::-;58520:87;;;58563:28;;;;;;;;;;:::i;:::-;;;;;;;;58520:87;58621:20;58627:4;58633:7;58621:5;:20::i;:::-;58661:19;58675:4;58661:19;;;;;;:::i;:::-;;;;;;;;58455:697;;;58756:29;58804:21;58844:14;58887:4;;58876:42;;;;;;;:::i;:::-;58737:181;;;;;;58937:9;58933:208;;;58967:59;58983:21;59006:13;59021:4;58967:15;:59::i;:::-;58933:208;;;59067:58;59082:21;59105:13;59120:4;59067:14;:58::i;:::-;58933:208;58455:697;;;;58354:805;;;:::o;24692:539::-;24816:1;24798:20;;:6;:20;;;;24790:70;;;;;;;;;;;;:::i;:::-;;;;;;;;;24900:1;24879:23;;:9;:23;;;;24871:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;24955:47;24976:6;24984:9;24995:6;24955:20;:47::i;:::-;25035:71;25057:6;25035:71;;;;;;;;;;;;;;;;;:9;:17;25045:6;25035:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;25015:9;:17;25025:6;25015:17;;;;;;;;;;;;;;;:91;;;;25140:32;25165:6;25140:9;:20;25150:9;25140:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;25117:9;:20;25127:9;25117:20;;;;;;;;;;;;;;;:55;;;;25205:9;25188:35;;25197:6;25188:35;;;25216:6;25188:35;;;;;;:::i;:::-;;;;;;;;24692:539;;;:::o;7943:192::-;8029:7;8062:1;8057;:6;;8065:12;8049:29;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;8089:9;8105:1;8101;:5;8089:17;;8126:1;8119:8;;;7943:192;;;;;:::o;7040:181::-;7098:7;7118:9;7134:1;7130;:5;7118:17;;7159:1;7154;:6;;7146:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;7212:1;7205:8;;;7040:181;;;;:::o;57175:441::-;57325:29;57365:21;57325:62;;57398:21;:38;;;57459:4;57479:9;57503:13;57398:129;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57545:63;57560:9;57571:21;57594:13;57545:63;;;;;;;;:::i;:::-;;;;;;;;57175:441;;;;:::o;50120:149::-;50194:7;50237:22;50241:3;:10;;50253:5;50237:3;:22::i;:::-;50229:31;;50214:47;;50120:149;;;;:::o;48861:143::-;48931:4;48955:41;48960:3;:10;;48988:5;48980:14;;48972:23;;48955:4;:41::i;:::-;48948:48;;48861:143;;;;:::o;25512:378::-;25615:1;25596:21;;:7;:21;;;;25588:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;25666:49;25695:1;25699:7;25708:6;25666:20;:49::i;:::-;25743:24;25760:6;25743:12;;:16;;:24;;;;:::i;:::-;25728:12;:39;;;;25799:30;25822:6;25799:9;:18;25809:7;25799:18;;;;;;;;;;;;;;;;:22;;:30;;;;:::i;:::-;25778:9;:18;25788:7;25778:18;;;;;;;;;;;;;;;:51;;;;25866:7;25845:37;;25862:1;25845:37;;;25875:6;25845:37;;;;;;:::i;:::-;;;;;;;;25512:378;;:::o;49659:117::-;49722:7;49749:19;49757:3;:10;;49749:7;:19::i;:::-;49742:26;;49659:117;;;:::o;13621:397::-;13736:6;13711:21;:31;;13703:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;13868:12;13886:9;:14;;13909:6;13886:35;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13867:54;;;13940:7;13932:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;13621:397;;;:::o;49180:149::-;49253:4;49277:44;49285:3;:10;;49313:5;49305:14;;49297:23;;49277:7;:44::i;:::-;49270:51;;49180:149;;;;:::o;28449:92::-;;;;:::o;7504:136::-;7562:7;7589:43;7593:1;7596;7589:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;7582:50;;7504:136;;;;:::o;47735:129::-;47808:4;47855:1;47832:3;:12;;:19;47845:5;47832:19;;;;;;;;;;;;:24;;47825:31;;47735:129;;;;:::o;48403:204::-;48470:7;48519:5;48498:3;:11;;:18;;;;:26;48490:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;48581:3;:11;;48593:5;48581:18;;;;;;;;;;;;;;;;48574:25;;48403:204;;;;:::o;45515:414::-;45578:4;45600:21;45610:3;45615:5;45600:9;:21::i;:::-;45595:327;;45638:3;:11;;45655:5;45638:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45821:3;:11;;:18;;;;45799:3;:12;;:19;45812:5;45799:19;;;;;;;;;;;:40;;;;45861:4;45854:11;;;;45595:327;45905:5;45898:12;;45515:414;;;;;:::o;47950:109::-;48006:7;48033:3;:11;;:18;;;;48026:25;;47950:109;;;:::o;46105:1544::-;46171:4;46289:18;46310:3;:12;;:19;46323:5;46310:19;;;;;;;;;;;;46289:40;;46360:1;46346:10;:15;46342:1300;;46708:21;46745:1;46732:10;:14;46708:38;;46761:17;46802:1;46781:3;:11;;:18;;;;:22;46761:42;;47048:17;47068:3;:11;;47080:9;47068:22;;;;;;;;;;;;;;;;47048:42;;47214:9;47185:3;:11;;47197:13;47185:26;;;;;;;;;;;;;;;:38;;;;47333:1;47317:13;:17;47291:3;:12;;:23;47304:9;47291:23;;;;;;;;;;;:43;;;;47443:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;47538:3;:12;;:19;47551:5;47538:19;;;;;;;;;;;47531:26;;;47581:4;47574:11;;;;;;;;46342:1300;47625:5;47618:12;;;46105:1544;;;;;:::o;5:130:-1:-;;85:6;72:20;63:29;;97:33;124:5;97:33;:::i;:::-;57:78;;;;:::o;142:134::-;;226:6;220:13;211:22;;238:33;265:5;238:33;:::i;:::-;205:71;;;;:::o;283:146::-;;371:6;358:20;349:29;;383:41;418:5;383:41;:::i;:::-;343:86;;;;:::o;454:707::-;;571:3;564:4;556:6;552:17;548:27;538:2;;589:1;586;579:12;538:2;626:6;613:20;648:80;663:64;720:6;663:64;:::i;:::-;648:80;:::i;:::-;639:89;;745:5;770:6;763:5;756:21;800:4;792:6;788:17;778:27;;822:4;817:3;813:14;806:21;;875:6;922:3;914:4;906:6;902:17;897:3;893:27;890:36;887:2;;;939:1;936;929:12;887:2;964:1;949:206;974:6;971:1;968:13;949:206;;;1032:3;1054:37;1087:3;1075:10;1054:37;:::i;:::-;1049:3;1042:50;1115:4;1110:3;1106:14;1099:21;;1143:4;1138:3;1134:14;1127:21;;1006:149;996:1;993;989:9;984:14;;949:206;;;953:14;531:630;;;;;;;:::o;1169:124::-;;1246:6;1233:20;1224:29;;1258:30;1282:5;1258:30;:::i;:::-;1218:75;;;;:::o;1300:128::-;;1379:6;1366:20;1357:29;;1391:32;1417:5;1391:32;:::i;:::-;1351:77;;;;:::o;1449:336::-;;;1563:3;1556:4;1548:6;1544:17;1540:27;1530:2;;1581:1;1578;1571:12;1530:2;1614:6;1601:20;1591:30;;1641:18;1633:6;1630:30;1627:2;;;1673:1;1670;1663:12;1627:2;1707:4;1699:6;1695:17;1683:29;;1758:3;1750:4;1742:6;1738:17;1728:8;1724:32;1721:41;1718:2;;;1775:1;1772;1765:12;1718:2;1523:262;;;;;:::o;1793:130::-;;1873:6;1860:20;1851:29;;1885:33;1912:5;1885:33;:::i;:::-;1845:78;;;;:::o;1930:134::-;;2014:6;2008:13;1999:22;;2026:33;2053:5;2026:33;:::i;:::-;1993:71;;;;:::o;2071:241::-;;2175:2;2163:9;2154:7;2150:23;2146:32;2143:2;;;2191:1;2188;2181:12;2143:2;2226:1;2243:53;2288:7;2279:6;2268:9;2264:22;2243:53;:::i;:::-;2233:63;;2205:97;2137:175;;;;:::o;2319:263::-;;2434:2;2422:9;2413:7;2409:23;2405:32;2402:2;;;2450:1;2447;2440:12;2402:2;2485:1;2502:64;2558:7;2549:6;2538:9;2534:22;2502:64;:::i;:::-;2492:74;;2464:108;2396:186;;;;:::o;2589:257::-;;2701:2;2689:9;2680:7;2676:23;2672:32;2669:2;;;2717:1;2714;2707:12;2669:2;2752:1;2769:61;2822:7;2813:6;2802:9;2798:22;2769:61;:::i;:::-;2759:71;;2731:105;2663:183;;;;:::o;2853:501::-;;;;2996:2;2984:9;2975:7;2971:23;2967:32;2964:2;;;3012:1;3009;3002:12;2964:2;3047:1;3064:61;3117:7;3108:6;3097:9;3093:22;3064:61;:::i;:::-;3054:71;;3026:105;3162:2;3180:53;3225:7;3216:6;3205:9;3201:22;3180:53;:::i;:::-;3170:63;;3141:98;3270:2;3288:50;3330:7;3321:6;3310:9;3306:22;3288:50;:::i;:::-;3278:60;;3249:95;2958:396;;;;;:::o;3361:366::-;;;3482:2;3470:9;3461:7;3457:23;3453:32;3450:2;;;3498:1;3495;3488:12;3450:2;3533:1;3550:53;3595:7;3586:6;3575:9;3571:22;3550:53;:::i;:::-;3540:63;;3512:97;3640:2;3658:53;3703:7;3694:6;3683:9;3679:22;3658:53;:::i;:::-;3648:63;;3619:98;3444:283;;;;;:::o;3734:491::-;;;;3872:2;3860:9;3851:7;3847:23;3843:32;3840:2;;;3888:1;3885;3878:12;3840:2;3923:1;3940:53;3985:7;3976:6;3965:9;3961:22;3940:53;:::i;:::-;3930:63;;3902:97;4030:2;4048:53;4093:7;4084:6;4073:9;4069:22;4048:53;:::i;:::-;4038:63;;4009:98;4138:2;4156:53;4201:7;4192:6;4181:9;4177:22;4156:53;:::i;:::-;4146:63;;4117:98;3834:391;;;;;:::o;4232:741::-;;;;;;4406:3;4394:9;4385:7;4381:23;4377:33;4374:2;;;4423:1;4420;4413:12;4374:2;4458:1;4475:53;4520:7;4511:6;4500:9;4496:22;4475:53;:::i;:::-;4465:63;;4437:97;4565:2;4583:53;4628:7;4619:6;4608:9;4604:22;4583:53;:::i;:::-;4573:63;;4544:98;4673:2;4691:53;4736:7;4727:6;4716:9;4712:22;4691:53;:::i;:::-;4681:63;;4652:98;4809:2;4798:9;4794:18;4781:32;4833:18;4825:6;4822:30;4819:2;;;4865:1;4862;4855:12;4819:2;4893:64;4949:7;4940:6;4929:9;4925:22;4893:64;:::i;:::-;4875:82;;;;4760:203;4368:605;;;;;;;;:::o;4980:867::-;;;;;;;5171:3;5159:9;5150:7;5146:23;5142:33;5139:2;;;5188:1;5185;5178:12;5139:2;5223:1;5240:53;5285:7;5276:6;5265:9;5261:22;5240:53;:::i;:::-;5230:63;;5202:97;5330:2;5348:53;5393:7;5384:6;5373:9;5369:22;5348:53;:::i;:::-;5338:63;;5309:98;5438:2;5456:53;5501:7;5492:6;5481:9;5477:22;5456:53;:::i;:::-;5446:63;;5417:98;5546:2;5564:53;5609:7;5600:6;5589:9;5585:22;5564:53;:::i;:::-;5554:63;;5525:98;5682:3;5671:9;5667:19;5654:33;5707:18;5699:6;5696:30;5693:2;;;5739:1;5736;5729:12;5693:2;5767:64;5823:7;5814:6;5803:9;5799:22;5767:64;:::i;:::-;5749:82;;;;5633:204;5133:714;;;;;;;;:::o;5854:490::-;;;;5994:2;5982:9;5973:7;5969:23;5965:32;5962:2;;;6010:1;6007;6000:12;5962:2;6045:1;6062:53;6107:7;6098:6;6087:9;6083:22;6062:53;:::i;:::-;6052:63;;6024:97;6180:2;6169:9;6165:18;6152:32;6204:18;6196:6;6193:30;6190:2;;;6236:1;6233;6226:12;6190:2;6264:64;6320:7;6311:6;6300:9;6296:22;6264:64;:::i;:::-;6246:82;;;;6131:203;5956:388;;;;;:::o;6351:366::-;;;6472:2;6460:9;6451:7;6447:23;6443:32;6440:2;;;6488:1;6485;6478:12;6440:2;6523:1;6540:53;6585:7;6576:6;6565:9;6561:22;6540:53;:::i;:::-;6530:63;;6502:97;6630:2;6648:53;6693:7;6684:6;6673:9;6669:22;6648:53;:::i;:::-;6638:63;;6609:98;6434:283;;;;;:::o;6724:235::-;;6825:2;6813:9;6804:7;6800:23;6796:32;6793:2;;;6841:1;6838;6831:12;6793:2;6876:1;6893:50;6935:7;6926:6;6915:9;6911:22;6893:50;:::i;:::-;6883:60;;6855:94;6787:172;;;;:::o;6966:496::-;;;7109:2;7097:9;7088:7;7084:23;7080:32;7077:2;;;7125:1;7122;7115:12;7077:2;7160:1;7177:50;7219:7;7210:6;7199:9;7195:22;7177:50;:::i;:::-;7167:60;;7139:94;7292:2;7281:9;7277:18;7264:32;7316:18;7308:6;7305:30;7302:2;;;7348:1;7345;7338:12;7302:2;7368:78;7438:7;7429:6;7418:9;7414:22;7368:78;:::i;:::-;7358:88;;7243:209;7071:391;;;;;:::o;7469:485::-;;;;7604:2;7592:9;7583:7;7579:23;7575:32;7572:2;;;7620:1;7617;7610:12;7572:2;7655:1;7672:50;7714:7;7705:6;7694:9;7690:22;7672:50;:::i;:::-;7662:60;;7634:94;7759:2;7777:53;7822:7;7813:6;7802:9;7798:22;7777:53;:::i;:::-;7767:63;;7738:98;7867:2;7885:53;7930:7;7921:6;7910:9;7906:22;7885:53;:::i;:::-;7875:63;;7846:98;7566:388;;;;;:::o;7961:239::-;;8064:2;8052:9;8043:7;8039:23;8035:32;8032:2;;;8080:1;8077;8070:12;8032:2;8115:1;8132:52;8176:7;8167:6;8156:9;8152:22;8132:52;:::i;:::-;8122:62;;8094:96;8026:174;;;;:::o;8207:241::-;;8311:2;8299:9;8290:7;8286:23;8282:32;8279:2;;;8327:1;8324;8317:12;8279:2;8362:1;8379:53;8424:7;8415:6;8404:9;8400:22;8379:53;:::i;:::-;8369:63;;8341:97;8273:175;;;;:::o;8455:263::-;;8570:2;8558:9;8549:7;8545:23;8541:32;8538:2;;;8586:1;8583;8576:12;8538:2;8621:1;8638:64;8694:7;8685:6;8674:9;8670:22;8638:64;:::i;:::-;8628:74;;8600:108;8532:186;;;;:::o;8726:173::-;;8813:46;8855:3;8847:6;8813:46;:::i;:::-;8888:4;8883:3;8879:14;8865:28;;8806:93;;;;:::o;8907:142::-;8998:45;9037:5;8998:45;:::i;:::-;8993:3;8986:58;8980:69;;:::o;9056:137::-;9155:32;9181:5;9155:32;:::i;:::-;9150:3;9143:45;9137:56;;:::o;9200:103::-;9273:24;9291:5;9273:24;:::i;:::-;9268:3;9261:37;9255:48;;:::o;9310:113::-;9393:24;9411:5;9393:24;:::i;:::-;9388:3;9381:37;9375:48;;:::o;9461:690::-;;9606:54;9654:5;9606:54;:::i;:::-;9673:86;9752:6;9747:3;9673:86;:::i;:::-;9666:93;;9780:56;9830:5;9780:56;:::i;:::-;9856:7;9884:1;9869:260;9894:6;9891:1;9888:13;9869:260;;;9961:6;9955:13;9982:63;10041:3;10026:13;9982:63;:::i;:::-;9975:70;;10062:60;10115:6;10062:60;:::i;:::-;10052:70;;9926:203;9916:1;9913;9909:9;9904:14;;9869:260;;;9873:14;10142:3;10135:10;;9585:566;;;;;;;:::o;10159:104::-;10236:21;10251:5;10236:21;:::i;:::-;10231:3;10224:34;10218:45;;:::o;10270:110::-;10351:23;10368:5;10351:23;:::i;:::-;10346:3;10339:36;10333:47;;:::o;10410:310::-;;10542:88;10623:6;10618:3;10542:88;:::i;:::-;10535:95;;10642:43;10678:6;10673:3;10666:5;10642:43;:::i;:::-;10707:6;10702:3;10698:16;10691:23;;10528:192;;;;;:::o;10728:347::-;;10840:39;10873:5;10840:39;:::i;:::-;10891:71;10955:6;10950:3;10891:71;:::i;:::-;10884:78;;10967:52;11012:6;11007:3;11000:4;10993:5;10989:16;10967:52;:::i;:::-;11040:29;11062:6;11040:29;:::i;:::-;11035:3;11031:39;11024:46;;10820:255;;;;;:::o;11083:371::-;;11243:67;11307:2;11302:3;11243:67;:::i;:::-;11236:74;;11343:34;11339:1;11334:3;11330:11;11323:55;11412:4;11407:2;11402:3;11398:12;11391:26;11445:2;11440:3;11436:12;11429:19;;11229:225;;;:::o;11463:372::-;;11623:67;11687:2;11682:3;11623:67;:::i;:::-;11616:74;;11723:34;11719:1;11714:3;11710:11;11703:55;11792:5;11787:2;11782:3;11778:12;11771:27;11826:2;11821:3;11817:12;11810:19;;11609:226;;;:::o;11844:331::-;;12004:67;12068:2;12063:3;12004:67;:::i;:::-;11997:74;;12104:33;12100:1;12095:3;12091:11;12084:54;12166:2;12161:3;12157:12;12150:19;;11990:185;;;:::o;12184:375::-;;12344:67;12408:2;12403:3;12344:67;:::i;:::-;12337:74;;12444:34;12440:1;12435:3;12431:11;12424:55;12513:8;12508:2;12503:3;12499:12;12492:30;12550:2;12545:3;12541:12;12534:19;;12330:229;;;:::o;12568:371::-;;12728:67;12792:2;12787:3;12728:67;:::i;:::-;12721:74;;12828:34;12824:1;12819:3;12815:11;12808:55;12897:4;12892:2;12887:3;12883:12;12876:26;12930:2;12925:3;12921:12;12914:19;;12714:225;;;:::o;12948:327::-;;13108:67;13172:2;13167:3;13108:67;:::i;:::-;13101:74;;13208:29;13204:1;13199:3;13195:11;13188:50;13266:2;13261:3;13257:12;13250:19;;13094:181;;;:::o;13284:313::-;;13444:67;13508:2;13503:3;13444:67;:::i;:::-;13437:74;;13544:15;13540:1;13535:3;13531:11;13524:36;13588:2;13583:3;13579:12;13572:19;;13430:167;;;:::o;13606:315::-;;13766:67;13830:2;13825:3;13766:67;:::i;:::-;13759:74;;13866:17;13862:1;13857:3;13853:11;13846:38;13912:2;13907:3;13903:12;13896:19;;13752:169;;;:::o;13930:395::-;;14090:67;14154:2;14149:3;14090:67;:::i;:::-;14083:74;;14190:34;14186:1;14181:3;14177:11;14170:55;14259:28;14254:2;14249:3;14245:12;14238:50;14316:2;14311:3;14307:12;14300:19;;14076:249;;;:::o;14334:329::-;;14494:67;14558:2;14553:3;14494:67;:::i;:::-;14487:74;;14594:31;14590:1;14585:3;14581:11;14574:52;14654:2;14649:3;14645:12;14638:19;;14480:183;;;:::o;14672:323::-;;14832:67;14896:2;14891:3;14832:67;:::i;:::-;14825:74;;14932:25;14928:1;14923:3;14919:11;14912:46;14986:2;14981:3;14977:12;14970:19;;14818:177;;;:::o;15004:332::-;;15164:67;15228:2;15223:3;15164:67;:::i;:::-;15157:74;;15264:34;15260:1;15255:3;15251:11;15244:55;15327:2;15322:3;15318:12;15311:19;;15150:186;;;:::o;15345:370::-;;15505:67;15569:2;15564:3;15505:67;:::i;:::-;15498:74;;15605:34;15601:1;15596:3;15592:11;15585:55;15674:3;15669:2;15664:3;15660:12;15653:25;15706:2;15701:3;15697:12;15690:19;;15491:224;;;:::o;15724:374::-;;15884:67;15948:2;15943:3;15884:67;:::i;:::-;15877:74;;15984:34;15980:1;15975:3;15971:11;15964:55;16053:7;16048:2;16043:3;16039:12;16032:29;16089:2;16084:3;16080:12;16073:19;;15870:228;;;:::o;16107:260::-;;16266:65;16329:1;16324:3;16266:65;:::i;:::-;16259:72;;16359:1;16354:3;16350:11;16343:18;;16252:115;;;:::o;16376:296::-;;16553:83;16634:1;16629:3;16553:83;:::i;:::-;16546:90;;16664:1;16659:3;16655:11;16648:18;;16539:133;;;:::o;16681:373::-;;16841:67;16905:2;16900:3;16841:67;:::i;:::-;16834:74;;16941:34;16937:1;16932:3;16928:11;16921:55;17010:6;17005:2;17000:3;16996:12;16989:28;17045:2;17040:3;17036:12;17029:19;;16827:227;;;:::o;17063:318::-;;17223:67;17287:2;17282:3;17223:67;:::i;:::-;17216:74;;17323:20;17319:1;17314:3;17310:11;17303:41;17372:2;17367:3;17363:12;17356:19;;17209:172;;;:::o;17390:328::-;;17550:67;17614:2;17609:3;17550:67;:::i;:::-;17543:74;;17650:30;17646:1;17641:3;17637:11;17630:51;17709:2;17704:3;17700:12;17693:19;;17536:182;;;:::o;17727:319::-;;17887:67;17951:2;17946:3;17887:67;:::i;:::-;17880:74;;17987:21;17983:1;17978:3;17974:11;17967:42;18037:2;18032:3;18028:12;18021:19;;17873:173;;;:::o;18055:331::-;;18215:67;18279:2;18274:3;18215:67;:::i;:::-;18208:74;;18315:33;18311:1;18306:3;18302:11;18295:54;18377:2;18372:3;18368:12;18361:19;;18201:185;;;:::o;18395:324::-;;18555:67;18619:2;18614:3;18555:67;:::i;:::-;18548:74;;18655:26;18651:1;18646:3;18642:11;18635:47;18710:2;18705:3;18701:12;18694:19;;18541:178;;;:::o;18727:113::-;18810:24;18828:5;18810:24;:::i;:::-;18805:3;18798:37;18792:48;;:::o;18847:107::-;18926:22;18942:5;18926:22;:::i;:::-;18921:3;18914:35;18908:46;;:::o;18961:291::-;;19124:103;19223:3;19214:6;19206;19124:103;:::i;:::-;19117:110;;19244:3;19237:10;;19105:147;;;;;:::o;19259:379::-;;19466:147;19609:3;19466:147;:::i;:::-;19459:154;;19630:3;19623:10;;19447:191;;;:::o;19645:222::-;;19772:2;19761:9;19757:18;19749:26;;19786:71;19854:1;19843:9;19839:17;19830:6;19786:71;:::i;:::-;19743:124;;;;:::o;19874:238::-;;20009:2;19998:9;19994:18;19986:26;;20023:79;20099:1;20088:9;20084:17;20075:6;20023:79;:::i;:::-;19980:132;;;;:::o;20119:254::-;;20262:2;20251:9;20247:18;20239:26;;20276:87;20360:1;20349:9;20345:17;20336:6;20276:87;:::i;:::-;20233:140;;;;:::o;20380:444::-;;20563:2;20552:9;20548:18;20540:26;;20577:71;20645:1;20634:9;20630:17;20621:6;20577:71;:::i;:::-;20659:72;20727:2;20716:9;20712:18;20703:6;20659:72;:::i;:::-;20742;20810:2;20799:9;20795:18;20786:6;20742:72;:::i;:::-;20534:290;;;;;;:::o;20831:556::-;;21042:3;21031:9;21027:19;21019:27;;21057:71;21125:1;21114:9;21110:17;21101:6;21057:71;:::i;:::-;21139:72;21207:2;21196:9;21192:18;21183:6;21139:72;:::i;:::-;21222;21290:2;21279:9;21275:18;21266:6;21222:72;:::i;:::-;21305;21373:2;21362:9;21358:18;21349:6;21305:72;:::i;:::-;21013:374;;;;;;;:::o;21394:860::-;;21705:3;21694:9;21690:19;21682:27;;21720:71;21788:1;21777:9;21773:17;21764:6;21720:71;:::i;:::-;21802:72;21870:2;21859:9;21855:18;21846:6;21802:72;:::i;:::-;21885;21953:2;21942:9;21938:18;21929:6;21885:72;:::i;:::-;21968;22036:2;22025:9;22021:18;22012:6;21968:72;:::i;:::-;22089:9;22083:4;22079:20;22073:3;22062:9;22058:19;22051:49;22114:130;22239:4;22114:130;:::i;:::-;22106:138;;21676:578;;;;;;;:::o;22261:333::-;;22416:2;22405:9;22401:18;22393:26;;22430:71;22498:1;22487:9;22483:17;22474:6;22430:71;:::i;:::-;22512:72;22580:2;22569:9;22565:18;22556:6;22512:72;:::i;:::-;22387:207;;;;;:::o;22601:370::-;;22778:2;22767:9;22763:18;22755:26;;22828:9;22822:4;22818:20;22814:1;22803:9;22799:17;22792:47;22853:108;22956:4;22947:6;22853:108;:::i;:::-;22845:116;;22749:222;;;;:::o;22978:210::-;;23099:2;23088:9;23084:18;23076:26;;23113:65;23175:1;23164:9;23160:17;23151:6;23113:65;:::i;:::-;23070:118;;;;:::o;23195:218::-;;23320:2;23309:9;23305:18;23297:26;;23334:69;23400:1;23389:9;23385:17;23376:6;23334:69;:::i;:::-;23291:122;;;;:::o;23420:310::-;;23567:2;23556:9;23552:18;23544:26;;23617:9;23611:4;23607:20;23603:1;23592:9;23588:17;23581:47;23642:78;23715:4;23706:6;23642:78;:::i;:::-;23634:86;;23538:192;;;;:::o;23737:416::-;;23937:2;23926:9;23922:18;23914:26;;23987:9;23981:4;23977:20;23973:1;23962:9;23958:17;23951:47;24012:131;24138:4;24012:131;:::i;:::-;24004:139;;23908:245;;;:::o;24160:416::-;;24360:2;24349:9;24345:18;24337:26;;24410:9;24404:4;24400:20;24396:1;24385:9;24381:17;24374:47;24435:131;24561:4;24435:131;:::i;:::-;24427:139;;24331:245;;;:::o;24583:416::-;;24783:2;24772:9;24768:18;24760:26;;24833:9;24827:4;24823:20;24819:1;24808:9;24804:17;24797:47;24858:131;24984:4;24858:131;:::i;:::-;24850:139;;24754:245;;;:::o;25006:416::-;;25206:2;25195:9;25191:18;25183:26;;25256:9;25250:4;25246:20;25242:1;25231:9;25227:17;25220:47;25281:131;25407:4;25281:131;:::i;:::-;25273:139;;25177:245;;;:::o;25429:416::-;;25629:2;25618:9;25614:18;25606:26;;25679:9;25673:4;25669:20;25665:1;25654:9;25650:17;25643:47;25704:131;25830:4;25704:131;:::i;:::-;25696:139;;25600:245;;;:::o;25852:416::-;;26052:2;26041:9;26037:18;26029:26;;26102:9;26096:4;26092:20;26088:1;26077:9;26073:17;26066:47;26127:131;26253:4;26127:131;:::i;:::-;26119:139;;26023:245;;;:::o;26275:416::-;;26475:2;26464:9;26460:18;26452:26;;26525:9;26519:4;26515:20;26511:1;26500:9;26496:17;26489:47;26550:131;26676:4;26550:131;:::i;:::-;26542:139;;26446:245;;;:::o;26698:416::-;;26898:2;26887:9;26883:18;26875:26;;26948:9;26942:4;26938:20;26934:1;26923:9;26919:17;26912:47;26973:131;27099:4;26973:131;:::i;:::-;26965:139;;26869:245;;;:::o;27121:416::-;;27321:2;27310:9;27306:18;27298:26;;27371:9;27365:4;27361:20;27357:1;27346:9;27342:17;27335:47;27396:131;27522:4;27396:131;:::i;:::-;27388:139;;27292:245;;;:::o;27544:416::-;;27744:2;27733:9;27729:18;27721:26;;27794:9;27788:4;27784:20;27780:1;27769:9;27765:17;27758:47;27819:131;27945:4;27819:131;:::i;:::-;27811:139;;27715:245;;;:::o;27967:416::-;;28167:2;28156:9;28152:18;28144:26;;28217:9;28211:4;28207:20;28203:1;28192:9;28188:17;28181:47;28242:131;28368:4;28242:131;:::i;:::-;28234:139;;28138:245;;;:::o;28390:416::-;;28590:2;28579:9;28575:18;28567:26;;28640:9;28634:4;28630:20;28626:1;28615:9;28611:17;28604:47;28665:131;28791:4;28665:131;:::i;:::-;28657:139;;28561:245;;;:::o;28813:416::-;;29013:2;29002:9;28998:18;28990:26;;29063:9;29057:4;29053:20;29049:1;29038:9;29034:17;29027:47;29088:131;29214:4;29088:131;:::i;:::-;29080:139;;28984:245;;;:::o;29236:416::-;;29436:2;29425:9;29421:18;29413:26;;29486:9;29480:4;29476:20;29472:1;29461:9;29457:17;29450:47;29511:131;29637:4;29511:131;:::i;:::-;29503:139;;29407:245;;;:::o;29659:416::-;;29859:2;29848:9;29844:18;29836:26;;29909:9;29903:4;29899:20;29895:1;29884:9;29880:17;29873:47;29934:131;30060:4;29934:131;:::i;:::-;29926:139;;29830:245;;;:::o;30082:416::-;;30282:2;30271:9;30267:18;30259:26;;30332:9;30326:4;30322:20;30318:1;30307:9;30303:17;30296:47;30357:131;30483:4;30357:131;:::i;:::-;30349:139;;30253:245;;;:::o;30505:416::-;;30705:2;30694:9;30690:18;30682:26;;30755:9;30749:4;30745:20;30741:1;30730:9;30726:17;30719:47;30780:131;30906:4;30780:131;:::i;:::-;30772:139;;30676:245;;;:::o;30928:416::-;;31128:2;31117:9;31113:18;31105:26;;31178:9;31172:4;31168:20;31164:1;31153:9;31149:17;31142:47;31203:131;31329:4;31203:131;:::i;:::-;31195:139;;31099:245;;;:::o;31351:416::-;;31551:2;31540:9;31536:18;31528:26;;31601:9;31595:4;31591:20;31587:1;31576:9;31572:17;31565:47;31626:131;31752:4;31626:131;:::i;:::-;31618:139;;31522:245;;;:::o;31774:416::-;;31974:2;31963:9;31959:18;31951:26;;32024:9;32018:4;32014:20;32010:1;31999:9;31995:17;31988:47;32049:131;32175:4;32049:131;:::i;:::-;32041:139;;31945:245;;;:::o;32197:222::-;;32324:2;32313:9;32309:18;32301:26;;32338:71;32406:1;32395:9;32391:17;32382:6;32338:71;:::i;:::-;32295:124;;;;:::o;32426:214::-;;32549:2;32538:9;32534:18;32526:26;;32563:67;32627:1;32616:9;32612:17;32603:6;32563:67;:::i;:::-;32520:120;;;;:::o;32647:256::-;;32709:2;32703:9;32693:19;;32747:4;32739:6;32735:17;32846:6;32834:10;32831:22;32810:18;32798:10;32795:34;32792:62;32789:2;;;32867:1;32864;32857:12;32789:2;32887:10;32883:2;32876:22;32687:216;;;;:::o;32910:304::-;;33069:18;33061:6;33058:30;33055:2;;;33101:1;33098;33091:12;33055:2;33136:4;33128:6;33124:17;33116:25;;33199:4;33193;33189:15;33181:23;;32992:222;;;:::o;33221:151::-;;33307:3;33299:11;;33345:4;33340:3;33336:14;33328:22;;33293:79;;;:::o;33379:137::-;;33488:5;33482:12;33472:22;;33453:63;;;:::o;33523:122::-;;33617:5;33611:12;33601:22;;33582:63;;;:::o;33652:108::-;;33750:4;33745:3;33741:14;33733:22;;33727:33;;;:::o;33768:178::-;;33898:6;33893:3;33886:19;33935:4;33930:3;33926:14;33911:29;;33879:67;;;;:::o;33955:162::-;;34069:6;34064:3;34057:19;34106:4;34101:3;34097:14;34082:29;;34050:67;;;;:::o;34126:144::-;;34261:3;34246:18;;34239:31;;;;:::o;34279:163::-;;34394:6;34389:3;34382:19;34431:4;34426:3;34422:14;34407:29;;34375:67;;;;:::o;34450:91::-;;34512:24;34530:5;34512:24;:::i;:::-;34501:35;;34495:46;;;:::o;34548:99::-;;34618:24;34636:5;34618:24;:::i;:::-;34607:35;;34601:46;;;:::o;34654:85::-;;34727:5;34720:13;34713:21;34702:32;;34696:43;;;:::o;34746:144::-;;34818:66;34811:5;34807:78;34796:89;;34790:100;;;:::o;34897:121::-;;34970:42;34963:5;34959:54;34948:65;;34942:76;;;:::o;35025:72::-;;35087:5;35076:16;;35070:27;;;:::o;35104:81::-;;35175:4;35168:5;35164:16;35153:27;;35147:38;;;:::o;35192:129::-;;35279:37;35310:5;35279:37;:::i;:::-;35266:50;;35260:61;;;:::o;35328:121::-;;35407:37;35438:5;35407:37;:::i;:::-;35394:50;;35388:61;;;:::o;35456:108::-;;35535:24;35553:5;35535:24;:::i;:::-;35522:37;;35516:48;;;:::o;35572:145::-;35653:6;35648:3;35643;35630:30;35709:1;35700:6;35695:3;35691:16;35684:27;35623:94;;;:::o;35726:268::-;35791:1;35798:101;35812:6;35809:1;35806:13;35798:101;;;35888:1;35883:3;35879:11;35873:18;35869:1;35864:3;35860:11;35853:39;35834:2;35831:1;35827:10;35822:15;;35798:101;;;35914:6;35911:1;35908:13;35905:2;;;35979:1;35970:6;35965:3;35961:16;35954:27;35905:2;35775:219;;;;:::o;36002:97::-;;36090:2;36086:7;36081:2;36074:5;36070:14;36066:28;36056:38;;36050:49;;;:::o;36107:117::-;36176:24;36194:5;36176:24;:::i;:::-;36169:5;36166:35;36156:2;;36215:1;36212;36205:12;36156:2;36150:74;:::o;36231:133::-;36308:32;36334:5;36308:32;:::i;:::-;36301:5;36298:43;36288:2;;36355:1;36352;36345:12;36288:2;36282:82;:::o;36371:111::-;36437:21;36452:5;36437:21;:::i;:::-;36430:5;36427:32;36417:2;;36473:1;36470;36463:12;36417:2;36411:71;:::o;36489:115::-;36557:23;36574:5;36557:23;:::i;:::-;36550:5;36547:34;36537:2;;36595:1;36592;36585:12;36537:2;36531:73;:::o;36611:117::-;36680:24;36698:5;36680:24;:::i;:::-;36673:5;36670:35;36660:2;;36719:1;36716;36709:12;36660:2;36654:74;:::o
Swarm Source
ipfs://889c3a0d2eb0231a87c50a6924f196f95e00cbd3d48c0c4faeb17f125832838e
Loading...
Loading
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.