Token

Lil Baby Doodles (LBD)

ERC-721

Overview

Max Total Supply

1,432 LBD

Holders

362

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x582cd2d90b87b2eea1758356df8357613a7b1624

Filtered by Token Holder

0xf97CD39Ac1ccc6B64Ca2756D4564B94eE4f9c7E4

leomeo.eth

Balance

1 LBD

0xf97CD39Ac1ccc6B64Ca2756D4564B94eE4f9c7E4

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

LilBabyDoodles

Compiler Version

v0.7.6+commit.7338295f

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-11-17
*/

// SPDX-License-Identifier: MIT

// File: @openzeppelin/contracts/utils/Context.sol

pragma solidity >=0.6.0 <0.8.0;

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with 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/introspection/IERC165.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () internal {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}


pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
      * @dev Safely transfers `tokenId` token from `from` to `to`.
      *
      * Requirements:
      *
      * - `from` cannot be the zero address.
      * - `to` cannot be the zero address.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Metadata.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Enumerable.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}

// File: @openzeppelin/contracts/introspection/ERC165.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts may inherit from this and call {_registerInterface} to declare
 * their support of an interface.
 */
abstract 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 virtual 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/math/SafeMath.sol

pragma solidity >=0.6.0 <0.8.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, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        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) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        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, reverting 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) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * 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);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

// File: @openzeppelin/contracts/utils/Address.sol

pragma solidity >=0.6.2 <0.8.0;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

// File: @openzeppelin/contracts/utils/EnumerableSet.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}

// File: @openzeppelin/contracts/utils/EnumerableMap.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Library for managing an enumerable variant of Solidity's
 * https://solidity.readthedocs.io/en/latest/types.html#mapping-types[`mapping`]
 * type.
 *
 * Maps have the following properties:
 *
 * - Entries are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Entries are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableMap for EnumerableMap.UintToAddressMap;
 *
 *     // Declare a set state variable
 *     EnumerableMap.UintToAddressMap private myMap;
 * }
 * ```
 *
 * As of v3.0.0, only maps of type `uint256 -> address` (`UintToAddressMap`) are
 * supported.
 */
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) { // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({ _key: key, _value: value }));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex != 0) { // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry 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.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function _contains(Map storage map, bytes32 key) private view returns (bool) {
        return map._indexes[key] != 0;
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

   /**
    * @dev Returns the key-value pair stored at position `index` in the map. O(1).
    *
    * Note that there are no guarantees on the ordering of entries inside the
    * array, and it may change when more entries are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        require(map._entries.length > index, "EnumerableMap: index out of bounds");

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
        return _remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
        return _contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map) internal view returns (uint256) {
        return _length(map._inner);
    }

   /**
    * @dev Returns the element 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(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (uint256(key), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        uint256 index = digits - 1;
        temp = value;
        while (temp != 0) {
            buffer[index--] = bytes1(uint8(48 + temp % 10));
            temp /= 10;
        }
        return string(buffer);
    }
}

// File: @openzeppelin/contracts/token/ERC721/ERC721.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
 
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using SafeMath for uint256;
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    // Mapping from holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

    // Mapping from token ID to approved address
    mapping (uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping (address => mapping (address => bool)) private _operatorApprovals;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Optional mapping for token URIs
    mapping (uint256 => string) private _tokenURIs;

    // Base URI
    string private _baseURI;

    /*
     *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
     *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
     *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
     *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
     *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c5
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
     *
     *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
     *        0xa22cb465 ^ 0xe985e9c5 ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    /*
     *     bytes4(keccak256('name()')) == 0x06fdde03
     *     bytes4(keccak256('symbol()')) == 0x95d89b41
     *     bytes4(keccak256('tokenURI(uint256)')) == 0xc87b56dd
     *
     *     => 0x06fdde03 ^ 0x95d89b41 ^ 0xc87b56dd == 0x5b5e139f
     */
    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;

    /*
     *     bytes4(keccak256('totalSupply()')) == 0x18160ddd
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) == 0x2f745c59
     *     bytes4(keccak256('tokenByIndex(uint256)')) == 0x4f6ccce7
     *
     *     => 0x18160ddd ^ 0x2f745c59 ^ 0x4f6ccce7 == 0x780e9d63
     */
    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor (string memory name_, string memory symbol_) public {
        _name = name_;
        _symbol = symbol_;

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _holderTokens[owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }
        // If there is a baseURI but no tokenURI, concatenate the tokenID to the baseURI.
        return string(abi.encodePacked(base, tokenId.toString()));
    }

    /**
    * @dev Returns the base URI set via {_setBaseURI}. This will be
    * automatically added as a prefix in {tokenURI} to each token's URI, or
    * to the token ID if no specific URI is set for that token ID.
    */
    function baseURI() public view virtual returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        return _holderTokens[owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return tokenId;
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(_msgSender() == owner || ERC721.isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _tokenOwners.contains(tokenId);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
        _mint(to, tokenId);
        require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId); // internal owner

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }

        _holderTokens[owner].remove(tokenId);

        _tokenOwners.remove(tokenId);

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721Metadata: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @dev Internal function to set the base URI for all token IDs. It is
     * automatically added as a prefix to the value returned in {tokenURI},
     * or to the token ID if {tokenURI} is empty.
     */
    function _setBaseURI(string memory baseURI_) internal virtual {
        _baseURI = baseURI_;
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
        private returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }
        bytes memory returndata = to.functionCall(abi.encodeWithSelector(
            IERC721Receiver(to).onERC721Received.selector,
            _msgSender(),
            from,
            tokenId,
            _data
        ), "ERC721: transfer to non ERC721Receiver implementer");
        bytes4 retval = abi.decode(returndata, (bytes4));
        return (retval == _ERC721_RECEIVED);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits an {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
}

// File: @openzeppelin/contracts/access/Ownable.sol

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual 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;
    }
}



pragma solidity ^0.7.0;
pragma abicoder v2;

contract LilBabyDoodles is ERC721, Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    
    bool public saleIsActive = false;
    string public FINAL_PROVENANCE = "";
    uint256 public constant tokenPrice = 30000000000000000;
    uint public constant maxTokenPurchase = 10;
    uint256 public constant MAX_TOKENS = 4444;
    mapping(address => uint256) private minted;
    
    
    constructor() ERC721("Lil Baby Doodles", "LBD") { }
    
    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        msg.sender.transfer(balance);
    }

    function setProvenanceHash(string memory provenanceHash) public onlyOwner {
        FINAL_PROVENANCE = provenanceHash;
    }

    function setBaseURI(string memory baseURI) public onlyOwner {
        _setBaseURI(baseURI);
    }

    function flipSaleState() public onlyOwner {
        saleIsActive = !saleIsActive;
    }
    
    function tokensOfOwner(address _owner) external view returns(uint256[] memory ) {
        uint256 tokenCount = balanceOf(_owner);
        if (tokenCount == 0) {
            // Return an empty array
            return new uint256[](0);
        } else {
            uint256[] memory result = new uint256[](tokenCount);
            uint256 index;
            for (index = 0; index < tokenCount; index++) {
                result[index] = tokenOfOwnerByIndex(_owner, index);
            }
            return result;
        }
    }
    
    function remainingMint(address user) public view returns (uint256) {
      require(saleIsActive, "Sale isn't active");
      return maxTokenPurchase - minted[user];
    }

    function mintToken(uint numberOfTokens) public payable nonReentrant {
        require(saleIsActive, "Sale must be active to mint");
        require(numberOfTokens > 0 && numberOfTokens <= maxTokenPurchase, "Can only mint 10 tokens at a time");
        require(totalSupply().add(numberOfTokens) <= MAX_TOKENS, "Purchase would exceed max supply");
        require(msg.value >= tokenPrice.mul(numberOfTokens), "Ether value sent is not correct");
        
        for(uint i = 0; i < numberOfTokens; i++) {
            uint mintIndex = totalSupply();
            if (totalSupply() < MAX_TOKENS) {
                _safeMint(msg.sender, mintIndex);
            }
        }

        minted[msg.sender] += numberOfTokens;
    }
     
    
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"FINAL_PROVENANCE","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TOKENS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"flipSaleState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxTokenPurchase","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mintToken","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"remainingMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"saleIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"provenanceHash","type":"string"}],"name":"setProvenanceHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

69420:2435:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12846:150;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54107:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56893:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56423:404;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69668:42;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70031:126;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55901:211;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57783:305;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;55663:162;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70272:89;;;;;;;;;;;;;:::i;:::-;;70925:173;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69889:134;;;;;;;;;;;;;:::i;:::-;;58159:151;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56189:172;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70165:99;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53863:177;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55482:97;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53580:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68814:148;;;;;;;;;;;;;:::i;:::-;;69607:54;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;70373:540;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;68163:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54276:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57186:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;58381:285;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;71106:733;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;54451:792;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57552:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69526:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69565:35;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;69117:244;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;69717:41;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;12846:150;12931:4;12955:20;:33;12976:11;12955:33;;;;;;;;;;;;;;;;;;;;;;;;;;;12948:40;;12846:150;;;:::o;54107:100::-;54161:13;54194:5;54187:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54107:100;:::o;56893:221::-;56969:7;56997:16;57005:7;56997;:16::i;:::-;56989:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;57082:15;:24;57098:7;57082:24;;;;;;;;;;;;;;;;;;;;;57075:31;;56893:221;;;:::o;56423:404::-;56504:13;56520:23;56535:7;56520:14;:23::i;:::-;56504:39;;56568:5;56562:11;;:2;:11;;;;56554:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;56648:5;56632:21;;:12;:10;:12::i;:::-;:21;;;:69;;;;56657:44;56681:5;56688:12;:10;:12::i;:::-;56657:23;:44::i;:::-;56632:69;56624:161;;;;;;;;;;;;:::i;:::-;;;;;;;;;56798:21;56807:2;56811:7;56798:8;:21::i;:::-;56423:404;;;:::o;69668:42::-;69708:2;69668:42;:::o;70031:126::-;68394:12;:10;:12::i;:::-;68383:23;;:7;:5;:7::i;:::-;:23;;;68375:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70135:14:::1;70116:16;:33;;;;;;;;;;;;:::i;:::-;;70031:126:::0;:::o;55901:211::-;55962:7;56083:21;:12;:19;:21::i;:::-;56076:28;;55901:211;:::o;57783:305::-;57944:41;57963:12;:10;:12::i;:::-;57977:7;57944:18;:41::i;:::-;57936:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;58052:28;58062:4;58068:2;58072:7;58052:9;:28::i;:::-;57783:305;;;:::o;55663:162::-;55760:7;55787:30;55811:5;55787:13;:20;55801:5;55787:20;;;;;;;;;;;;;;;:23;;:30;;;;:::i;:::-;55780:37;;55663:162;;;;:::o;70272:89::-;68394:12;:10;:12::i;:::-;68383:23;;:7;:5;:7::i;:::-;:23;;;68375:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70341:12:::1;;;;;;;;;;;70340:13;70325:12;;:28;;;;;;;;;;;;;;;;;;70272:89::o:0;70925:173::-;70983:7;71009:12;;;;;;;;;;;71001:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;71078:6;:12;71085:4;71078:12;;;;;;;;;;;;;;;;69708:2;71059:31;71052:38;;70925:173;;;:::o;69889:134::-;68394:12;:10;:12::i;:::-;68383:23;;:7;:5;:7::i;:::-;:23;;;68375:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;69937:15:::1;69955:21;69937:39;;69987:10;:19;;:28;70007:7;69987:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;68454:1;69889:134::o:0;58159:151::-;58263:39;58280:4;58286:2;58290:7;58263:39;;;;;;;;;;;;:16;:39::i;:::-;58159:151;;;:::o;56189:172::-;56264:7;56285:15;56306:22;56322:5;56306:12;:15;;:22;;;;:::i;:::-;56284:44;;;56346:7;56339:14;;;56189:172;;;:::o;70165:99::-;68394:12;:10;:12::i;:::-;68383:23;;:7;:5;:7::i;:::-;:23;;;68375:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;70236:20:::1;70248:7;70236:11;:20::i;:::-;70165:99:::0;:::o;53863:177::-;53935:7;53962:70;53979:7;53962:70;;;;;;;;;;;;;;;;;:12;:16;;:70;;;;;:::i;:::-;53955:77;;53863:177;;;:::o;55482:97::-;55530:13;55563:8;55556:15;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55482:97;:::o;53580:221::-;53652:7;53697:1;53680:19;;:5;:19;;;;53672:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;53764:29;:13;:20;53778:5;53764:20;;;;;;;;;;;;;;;:27;:29::i;:::-;53757:36;;53580:221;;;:::o;68814:148::-;68394:12;:10;:12::i;:::-;68383:23;;:7;:5;:7::i;:::-;:23;;;68375:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;68921:1:::1;68884:40;;68905:6;;;;;;;;;;;68884:40;;;;;;;;;;;;68952:1;68935:6;;:19;;;;;;;;;;;;;;;;;;68814:148::o:0;69607:54::-;69644:17;69607:54;:::o;70373:540::-;70434:16;70464:18;70485:17;70495:6;70485:9;:17::i;:::-;70464:38;;70531:1;70517:10;:15;70513:393;;;70608:1;70594:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70587:23;;;;;70513:393;70643:23;70683:10;70669:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70643:51;;70709:13;70737:130;70761:10;70753:5;:18;70737:130;;;70817:34;70837:6;70845:5;70817:19;:34::i;:::-;70801:6;70808:5;70801:13;;;;;;;;;;;;;:50;;;;;70773:7;;;;;;;70737:130;;;70888:6;70881:13;;;;;70373:540;;;;:::o;68163:87::-;68209:7;68236:6;;;;;;;;;;;68229:13;;68163:87;:::o;54276:104::-;54332:13;54365:7;54358:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54276:104;:::o;57186:295::-;57301:12;:10;:12::i;:::-;57289:24;;:8;:24;;;;57281:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;57401:8;57356:18;:32;57375:12;:10;:12::i;:::-;57356:32;;;;;;;;;;;;;;;:42;57389:8;57356:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;57454:8;57425:48;;57440:12;:10;:12::i;:::-;57425:48;;;57464:8;57425:48;;;;;;:::i;:::-;;;;;;;;57186:295;;:::o;58381:285::-;58513:41;58532:12;:10;:12::i;:::-;58546:7;58513:18;:41::i;:::-;58505:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;58619:39;58633:4;58639:2;58643:7;58652:5;58619:13;:39::i;:::-;58381:285;;;;:::o;71106:733::-;2769:1;3375:7;;:19;;3367:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;2769:1;3508:7;:18;;;;71193:12:::1;;;;;;;;;;;71185:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;71273:1;71256:14;:18;:56;;;;;69708:2;71278:14;:34;;71256:56;71248:102;;;;;;;;;;;;:::i;:::-;;;;;;;;;69754:4;71369:33;71387:14;71369:13;:11;:13::i;:::-;:17;;:33;;;;:::i;:::-;:47;;71361:92;;;;;;;;;;;;:::i;:::-;;;;;;;;;71485:30;71500:14;69644:17;71485:14;;:30;;;;:::i;:::-;71472:9;:43;;71464:87;;;;;;;;;;;;:::i;:::-;;;;;;;;;71576:6;71572:211;71592:14;71588:1;:18;71572:211;;;71628:14;71645:13;:11;:13::i;:::-;71628:30;;69754:4;71677:13;:11;:13::i;:::-;:26;71673:99;;;71724:32;71734:10;71746:9;71724;:32::i;:::-;71673:99;71572:211;71608:3;;;;;;;71572:211;;;;71817:14;71795:6;:18;71802:10;71795:18;;;;;;;;;;;;;;;;:36;;;;;;;;;;;2725:1:::0;3687:7;:22;;;;71106:733;:::o;54451:792::-;54524:13;54558:16;54566:7;54558;:16::i;:::-;54550:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;54639:23;54665:10;:19;54676:7;54665:19;;;;;;;;;;;54639:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54695:18;54716:9;:7;:9::i;:::-;54695:30;;54823:1;54807:4;54801:18;:23;54797:72;;;54848:9;54841:16;;;;;;54797:72;54999:1;54979:9;54973:23;:27;54969:108;;;55048:4;55054:9;55031:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;55017:48;;;;;;54969:108;55209:4;55215:18;:7;:16;:18::i;:::-;55192:42;;;;;;;;;:::i;:::-;;;;;;;;;;;;;55178:57;;;;54451:792;;;;:::o;57552:164::-;57649:4;57673:18;:25;57692:5;57673:25;;;;;;;;;;;;;;;:35;57699:8;57673:35;;;;;;;;;;;;;;;;;;;;;;;;;57666:42;;57552:164;;;;:::o;69526:32::-;;;;;;;;;;;;;:::o;69565:35::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;69117:244::-;68394:12;:10;:12::i;:::-;68383:23;;:7;:5;:7::i;:::-;:23;;;68375:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;69226:1:::1;69206:22;;:8;:22;;;;69198:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;69316:8;69287:38;;69308:6;;;;;;;;;;;69287:38;;;;;;;;;;;;69345:8;69336:6;;:17;;;;;;;;;;;;;;;;;;69117:244:::0;:::o;69717:41::-;69754:4;69717:41;:::o;60133:127::-;60198:4;60222:30;60244:7;60222:12;:21;;:30;;;;:::i;:::-;60215:37;;60133:127;;;:::o;667:106::-;720:15;755:10;748:17;;667:106;:::o;66151:192::-;66253:2;66226:15;:24;66242:7;66226:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;66309:7;66305:2;66271:46;;66280:23;66295:7;66280:14;:23::i;:::-;66271:46;;;;;;;;;;;;66151:192;;:::o;46873:123::-;46942:7;46969:19;46977:3;:10;;46969:7;:19::i;:::-;46962:26;;46873:123;;;:::o;60427:355::-;60520:4;60545:16;60553:7;60545;:16::i;:::-;60537:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;60621:13;60637:23;60652:7;60637:14;:23::i;:::-;60621:39;;60690:5;60679:16;;:7;:16;;;:51;;;;60723:7;60699:31;;:20;60711:7;60699:11;:20::i;:::-;:31;;;60679:51;:94;;;;60734:39;60758:5;60765:7;60734:23;:39::i;:::-;60679:94;60671:103;;;60427:355;;;;:::o;63563:599::-;63688:4;63661:31;;:23;63676:7;63661:14;:23::i;:::-;:31;;;63653:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;63789:1;63775:16;;:2;:16;;;;63767:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;63845:39;63866:4;63872:2;63876:7;63845:20;:39::i;:::-;63949:29;63966:1;63970:7;63949:8;:29::i;:::-;63991:35;64018:7;63991:13;:19;64005:4;63991:19;;;;;;;;;;;;;;;:26;;:35;;;;:::i;:::-;;64037:30;64059:7;64037:13;:17;64051:2;64037:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;64080:29;64097:7;64106:2;64080:12;:16;;:29;;;;;:::i;:::-;;64146:7;64142:2;64127:27;;64136:4;64127:27;;;;;;;;;;;;63563:599;;;:::o;38668:137::-;38739:7;38774:22;38778:3;:10;;38790:5;38774:3;:22::i;:::-;38766:31;;38759:38;;38668:137;;;;:::o;47335:236::-;47415:7;47424;47445:11;47458:13;47475:22;47479:3;:10;;47491:5;47475:3;:22::i;:::-;47444:53;;;;47524:3;47516:12;;47554:5;47546:14;;47508:55;;;;;;47335:236;;;;;:::o;64763:100::-;64847:8;64836;:19;;;;;;;;;;;;:::i;:::-;;64763:100;:::o;48621:213::-;48728:7;48779:44;48784:3;:10;;48804:3;48796:12;;48810;48779:4;:44::i;:::-;48771:53;;48748:78;;48621:213;;;;;:::o;38210:114::-;38270:7;38297:19;38305:3;:10;;38297:7;:19::i;:::-;38290:26;;38210:114;;;:::o;59548:272::-;59662:28;59672:4;59678:2;59682:7;59662:9;:28::i;:::-;59709:48;59732:4;59738:2;59742:7;59751:5;59709:22;:48::i;:::-;59701:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;59548:272;;;;:::o;16404:179::-;16462:7;16482:9;16498:1;16494;:5;16482:17;;16523:1;16518;:6;;16510:46;;;;;;;;;;;;:::i;:::-;;;;;;;;;16574:1;16567:8;;;16404:179;;;;:::o;17283:220::-;17341:7;17370:1;17365;:6;17361:20;;;17380:1;17373:8;;;;17361:20;17392:9;17408:1;17404;:5;17392:17;;17437:1;17432;17428;:5;;;;;;:10;17420:56;;;;;;;;;;;;:::i;:::-;;;;;;;;;17494:1;17487:8;;;17283:220;;;;;:::o;61125:110::-;61201:26;61211:2;61215:7;61201:26;;;;;;;;;;;;:9;:26::i;:::-;61125:110;;:::o;49081:746::-;49137:13;49367:1;49358:5;:10;49354:53;;;49385:10;;;;;;;;;;;;;;;;;;;;;49354:53;49417:12;49432:5;49417:20;;49448:14;49473:78;49488:1;49480:4;:9;49473:78;;49506:8;;;;;;;49537:2;49529:10;;;;;;;;;49473:78;;;49561:19;49593:6;49583:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49561:39;;49611:13;49636:1;49627:6;:10;49611:26;;49655:5;49648:12;;49671:117;49686:1;49678:4;:9;49671:117;;49747:2;49740:4;:9;;;;;;49735:2;:14;49722:29;;49704:6;49711:7;;;;;;;49704:15;;;;;;;;;;;:47;;;;;;;;;;;49774:2;49766:10;;;;;;;;;49671:117;;;49812:6;49798:21;;;;;;49081:746;;;;:::o;46634:151::-;46718:4;46742:35;46752:3;:10;;46772:3;46764:12;;46742:9;:35::i;:::-;46735:42;;46634:151;;;;:::o;43452:110::-;43508:7;43535:3;:12;;:19;;;;43528:26;;43452:110;;;:::o;66956:93::-;;;;:::o;37755:137::-;37825:4;37849:35;37857:3;:10;;37877:5;37869:14;;37849:7;:35::i;:::-;37842:42;;37755:137;;;;:::o;37448:131::-;37515:4;37539:32;37544:3;:10;;37564:5;37556:14;;37539:4;:32::i;:::-;37532:39;;37448:131;;;;:::o;46057:185::-;46146:4;46170:64;46175:3;:10;;46195:3;46187:12;;46225:5;46209:23;;46201:32;;46170:4;:64::i;:::-;46163:71;;46057:185;;;;;:::o;33706:204::-;33773:7;33822:5;33801:3;:11;;:18;;;;:26;33793:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;33884:3;:11;;33896:5;33884:18;;;;;;;;;;;;;;;;33877:25;;33706:204;;;;:::o;43917:279::-;43984:7;43993;44043:5;44021:3;:12;;:19;;;;:27;44013:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;44100:22;44125:3;:12;;44138:5;44125:19;;;;;;;;;;;;;;;;;;44100:44;;44163:5;:10;;;44175:5;:12;;;44155:33;;;;;43917:279;;;;;:::o;45414:319::-;45508:7;45528:16;45547:3;:12;;:17;45560:3;45547:17;;;;;;;;;;;;45528:36;;45595:1;45583:8;:13;;45598:12;45575:36;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;45665:3;:12;;45689:1;45678:8;:12;45665:26;;;;;;;;;;;;;;;;;;:33;;;45658:40;;;45414:319;;;;;:::o;33253:109::-;33309:7;33336:3;:11;;:18;;;;33329:25;;33253:109;;;:::o;65428:604::-;65549:4;65576:15;:2;:13;;;:15::i;:::-;65571:60;;65615:4;65608:11;;;;65571:60;65641:23;65667:252;65720:45;;;65780:12;:10;:12::i;:::-;65807:4;65826:7;65848:5;65683:181;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65667:252;;;;;;;;;;;;;;;;;:2;:15;;;;:252;;;;;:::i;:::-;65641:278;;65930:13;65957:10;65946:32;;;;;;;;;;;;:::i;:::-;65930:48;;50577:10;66007:16;;65997:26;;;:6;:26;;;;65989:35;;;;65428:604;;;;;;;:::o;61462:250::-;61558:18;61564:2;61568:7;61558:5;:18::i;:::-;61595:54;61626:1;61630:2;61634:7;61643:5;61595:22;:54::i;:::-;61587:117;;;;;;;;;;;;:::i;:::-;;;;;;;;;61462:250;;;:::o;43232:125::-;43303:4;43348:1;43327:3;:12;;:17;43340:3;43327:17;;;;;;;;;;;;:22;;43320:29;;43232:125;;;;:::o;31408:1544::-;31474:4;31592:18;31613:3;:12;;:19;31626:5;31613:19;;;;;;;;;;;;31592:40;;31663:1;31649:10;:15;31645:1300;;32011:21;32048:1;32035:10;:14;32011:38;;32064:17;32105:1;32084:3;:11;;:18;;;;:22;32064:42;;32351:17;32371:3;:11;;32383:9;32371:22;;;;;;;;;;;;;;;;32351:42;;32517:9;32488:3;:11;;32500:13;32488:26;;;;;;;;;;;;;;;:38;;;;32636:1;32620:13;:17;32594:3;:12;;:23;32607:9;32594:23;;;;;;;;;;;:43;;;;32746:3;:11;;:17;;;;;;;;;;;;;;;;;;;;;;;;32841:3;:12;;:19;32854:5;32841:19;;;;;;;;;;;32834:26;;;32884:4;32877:11;;;;;;;;31645:1300;32928:5;32921:12;;;31408:1544;;;;;:::o;30818:414::-;30881:4;30903:21;30913:3;30918:5;30903:9;:21::i;:::-;30898:327;;30941:3;:11;;30958:5;30941:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31124:3;:11;;:18;;;;31102:3;:12;;:19;31115:5;31102:19;;;;;;;;;;;:40;;;;31164:4;31157:11;;;;30898:327;31208:5;31201:12;;30818:414;;;;;:::o;40732:692::-;40808:4;40924:16;40943:3;:12;;:17;40956:3;40943:17;;;;;;;;;;;;40924:36;;40989:1;40977:8;:13;40973:444;;;41044:3;:12;;41062:38;;;;;;;;41079:3;41062:38;;;;41092:5;41062:38;;;41044:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41259:3;:12;;:19;;;;41239:3;:12;;:17;41252:3;41239:17;;;;;;;;;;;:39;;;;41300:4;41293:11;;;;;40973:444;41373:5;41337:3;:12;;41361:1;41350:8;:12;41337:26;;;;;;;;;;;;;;;;;;:33;;:41;;;;41400:5;41393:12;;;40732:692;;;;;;:::o;21841:422::-;21901:4;22109:12;22220:7;22208:20;22200:28;;22254:1;22247:4;:8;22240:15;;;21841:422;;;:::o;24759:195::-;24862:12;24894:52;24916:6;24924:4;24930:1;24933:12;24894:21;:52::i;:::-;24887:59;;24759:195;;;;;:::o;62048:404::-;62142:1;62128:16;;:2;:16;;;;62120:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;62201:16;62209:7;62201;:16::i;:::-;62200:17;62192:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;62263:45;62292:1;62296:2;62300:7;62263:20;:45::i;:::-;62321:30;62343:7;62321:13;:17;62335:2;62321:17;;;;;;;;;;;;;;;:21;;:30;;;;:::i;:::-;;62364:29;62381:7;62390:2;62364:12;:16;;:29;;;;;:::i;:::-;;62436:7;62432:2;62411:33;;62428:1;62411:33;;;;;;;;;;;;62048:404;;:::o;33038:129::-;33111:4;33158:1;33135:3;:12;;:19;33148:5;33135:19;;;;;;;;;;;;:24;;33128:31;;33038:129;;;;:::o;25811:530::-;25938:12;25996:5;25971:21;:30;;25963:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;26063:18;26074:6;26063:10;:18::i;:::-;26055:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;26189:12;26203:23;26230:6;:11;;26250:5;26258:4;26230:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26188:75;;;;26281:52;26299:7;26308:10;26320:12;26281:17;:52::i;:::-;26274:59;;;;25811:530;;;;;;:::o;28351:742::-;28466:12;28495:7;28491:595;;;28526:10;28519:17;;;;28491:595;28660:1;28640:10;:17;:21;28636:439;;;28903:10;28897:17;28964:15;28951:10;28947:2;28943:19;28936:44;28851:148;29046:12;29039:20;;;;;;;;;;;:::i;:::-;;;;;;;;28351:742;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:342:1:-;;109:64;124:48;165:6;124:48;:::i;:::-;109:64;:::i;:::-;100:73;;196:6;189:5;182:21;234:4;227:5;223:16;272:3;263:6;258:3;254:16;251:25;248:2;;;289:1;286;279:12;248:2;302:41;336:6;331:3;326;302:41;:::i;:::-;90:259;;;;;;:::o;355:344::-;;458:65;473:49;515:6;473:49;:::i;:::-;458:65;:::i;:::-;449:74;;546:6;539:5;532:21;584:4;577:5;573:16;622:3;613:6;608:3;604:16;601:25;598:2;;;639:1;636;629:12;598:2;652:41;686:6;681:3;676;652:41;:::i;:::-;439:260;;;;;;:::o;705:139::-;;789:6;776:20;767:29;;805:33;832:5;805:33;:::i;:::-;757:87;;;;:::o;850:133::-;;931:6;918:20;909:29;;947:30;971:5;947:30;:::i;:::-;899:84;;;;:::o;989:137::-;;1072:6;1059:20;1050:29;;1088:32;1114:5;1088:32;:::i;:::-;1040:86;;;;:::o;1132:141::-;;1219:6;1213:13;1204:22;;1235:32;1261:5;1235:32;:::i;:::-;1194:79;;;;:::o;1292:271::-;;1396:3;1389:4;1381:6;1377:17;1373:27;1363:2;;1414:1;1411;1404:12;1363:2;1454:6;1441:20;1479:78;1553:3;1545:6;1538:4;1530:6;1526:17;1479:78;:::i;:::-;1470:87;;1353:210;;;;;:::o;1583:273::-;;1688:3;1681:4;1673:6;1669:17;1665:27;1655:2;;1706:1;1703;1696:12;1655:2;1746:6;1733:20;1771:79;1846:3;1838:6;1831:4;1823:6;1819:17;1771:79;:::i;:::-;1762:88;;1645:211;;;;;:::o;1862:139::-;;1946:6;1933:20;1924:29;;1962:33;1989:5;1962:33;:::i;:::-;1914:87;;;;:::o;2007:262::-;;2115:2;2103:9;2094:7;2090:23;2086:32;2083:2;;;2131:1;2128;2121:12;2083:2;2174:1;2199:53;2244:7;2235:6;2224:9;2220:22;2199:53;:::i;:::-;2189:63;;2145:117;2073:196;;;;:::o;2275:407::-;;;2400:2;2388:9;2379:7;2375:23;2371:32;2368:2;;;2416:1;2413;2406:12;2368:2;2459:1;2484:53;2529:7;2520:6;2509:9;2505:22;2484:53;:::i;:::-;2474:63;;2430:117;2586:2;2612:53;2657:7;2648:6;2637:9;2633:22;2612:53;:::i;:::-;2602:63;;2557:118;2358:324;;;;;:::o;2688:552::-;;;;2830:2;2818:9;2809:7;2805:23;2801:32;2798:2;;;2846:1;2843;2836:12;2798:2;2889:1;2914:53;2959:7;2950:6;2939:9;2935:22;2914:53;:::i;:::-;2904:63;;2860:117;3016:2;3042:53;3087:7;3078:6;3067:9;3063:22;3042:53;:::i;:::-;3032:63;;2987:118;3144:2;3170:53;3215:7;3206:6;3195:9;3191:22;3170:53;:::i;:::-;3160:63;;3115:118;2788:452;;;;;:::o;3246:809::-;;;;;3414:3;3402:9;3393:7;3389:23;3385:33;3382:2;;;3431:1;3428;3421:12;3382:2;3474:1;3499:53;3544:7;3535:6;3524:9;3520:22;3499:53;:::i;:::-;3489:63;;3445:117;3601:2;3627:53;3672:7;3663:6;3652:9;3648:22;3627:53;:::i;:::-;3617:63;;3572:118;3729:2;3755:53;3800:7;3791:6;3780:9;3776:22;3755:53;:::i;:::-;3745:63;;3700:118;3885:2;3874:9;3870:18;3857:32;3916:18;3908:6;3905:30;3902:2;;;3948:1;3945;3938:12;3902:2;3976:62;4030:7;4021:6;4010:9;4006:22;3976:62;:::i;:::-;3966:72;;3828:220;3372:683;;;;;;;:::o;4061:401::-;;;4183:2;4171:9;4162:7;4158:23;4154:32;4151:2;;;4199:1;4196;4189:12;4151:2;4242:1;4267:53;4312:7;4303:6;4292:9;4288:22;4267:53;:::i;:::-;4257:63;;4213:117;4369:2;4395:50;4437:7;4428:6;4417:9;4413:22;4395:50;:::i;:::-;4385:60;;4340:115;4141:321;;;;;:::o;4468:407::-;;;4593:2;4581:9;4572:7;4568:23;4564:32;4561:2;;;4609:1;4606;4599:12;4561:2;4652:1;4677:53;4722:7;4713:6;4702:9;4698:22;4677:53;:::i;:::-;4667:63;;4623:117;4779:2;4805:53;4850:7;4841:6;4830:9;4826:22;4805:53;:::i;:::-;4795:63;;4750:118;4551:324;;;;;:::o;4881:260::-;;4988:2;4976:9;4967:7;4963:23;4959:32;4956:2;;;5004:1;5001;4994:12;4956:2;5047:1;5072:52;5116:7;5107:6;5096:9;5092:22;5072:52;:::i;:::-;5062:62;;5018:116;4946:195;;;;:::o;5147:282::-;;5265:2;5253:9;5244:7;5240:23;5236:32;5233:2;;;5281:1;5278;5271:12;5233:2;5324:1;5349:63;5404:7;5395:6;5384:9;5380:22;5349:63;:::i;:::-;5339:73;;5295:127;5223:206;;;;:::o;5435:375::-;;5553:2;5541:9;5532:7;5528:23;5524:32;5521:2;;;5569:1;5566;5559:12;5521:2;5640:1;5629:9;5625:17;5612:31;5670:18;5662:6;5659:30;5656:2;;;5702:1;5699;5692:12;5656:2;5730:63;5785:7;5776:6;5765:9;5761:22;5730:63;:::i;:::-;5720:73;;5583:220;5511:299;;;;:::o;5816:262::-;;5924:2;5912:9;5903:7;5899:23;5895:32;5892:2;;;5940:1;5937;5930:12;5892:2;5983:1;6008:53;6053:7;6044:6;6033:9;6029:22;6008:53;:::i;:::-;5998:63;;5954:117;5882:196;;;;:::o;6084:179::-;;6174:46;6216:3;6208:6;6174:46;:::i;:::-;6252:4;6247:3;6243:14;6229:28;;6164:99;;;;:::o;6269:142::-;6372:32;6398:5;6372:32;:::i;:::-;6367:3;6360:45;6350:61;;:::o;6417:118::-;6504:24;6522:5;6504:24;:::i;:::-;6499:3;6492:37;6482:53;;:::o;6571:732::-;;6719:54;6767:5;6719:54;:::i;:::-;6789:86;6868:6;6863:3;6789:86;:::i;:::-;6782:93;;6899:56;6949:5;6899:56;:::i;:::-;6978:7;7009:1;6994:284;7019:6;7016:1;7013:13;6994:284;;;7095:6;7089:13;7122:63;7181:3;7166:13;7122:63;:::i;:::-;7115:70;;7208:60;7261:6;7208:60;:::i;:::-;7198:70;;7054:224;7041:1;7038;7034:9;7029:14;;6994:284;;;6998:14;7294:3;7287:10;;6695:608;;;;;;;:::o;7309:109::-;7390:21;7405:5;7390:21;:::i;:::-;7385:3;7378:34;7368:50;;:::o;7424:360::-;;7538:38;7570:5;7538:38;:::i;:::-;7592:70;7655:6;7650:3;7592:70;:::i;:::-;7585:77;;7671:52;7716:6;7711:3;7704:4;7697:5;7693:16;7671:52;:::i;:::-;7748:29;7770:6;7748:29;:::i;:::-;7743:3;7739:39;7732:46;;7514:270;;;;;:::o;7790:373::-;;7922:38;7954:5;7922:38;:::i;:::-;7976:88;8057:6;8052:3;7976:88;:::i;:::-;7969:95;;8073:52;8118:6;8113:3;8106:4;8099:5;8095:16;8073:52;:::i;:::-;8150:6;8145:3;8141:16;8134:23;;7898:265;;;;;:::o;8169:364::-;;8285:39;8318:5;8285:39;:::i;:::-;8340:71;8404:6;8399:3;8340:71;:::i;:::-;8333:78;;8420:52;8465:6;8460:3;8453:4;8446:5;8442:16;8420:52;:::i;:::-;8497:29;8519:6;8497:29;:::i;:::-;8492:3;8488:39;8481:46;;8261:272;;;;;:::o;8539:377::-;;8673:39;8706:5;8673:39;:::i;:::-;8728:89;8810:6;8805:3;8728:89;:::i;:::-;8721:96;;8826:52;8871:6;8866:3;8859:4;8852:5;8848:16;8826:52;:::i;:::-;8903:6;8898:3;8894:16;8887:23;;8649:267;;;;;:::o;8922:366::-;;9085:67;9149:2;9144:3;9085:67;:::i;:::-;9078:74;;9182:34;9178:1;9173:3;9169:11;9162:55;9248:4;9243:2;9238:3;9234:12;9227:26;9279:2;9274:3;9270:12;9263:19;;9068:220;;;:::o;9294:382::-;;9457:67;9521:2;9516:3;9457:67;:::i;:::-;9450:74;;9554:34;9550:1;9545:3;9541:11;9534:55;9620:20;9615:2;9610:3;9606:12;9599:42;9667:2;9662:3;9658:12;9651:19;;9440:236;;;:::o;9682:370::-;;9845:67;9909:2;9904:3;9845:67;:::i;:::-;9838:74;;9942:34;9938:1;9933:3;9929:11;9922:55;10008:8;10003:2;9998:3;9994:12;9987:30;10043:2;10038:3;10034:12;10027:19;;9828:224;;;:::o;10058:326::-;;10221:67;10285:2;10280:3;10221:67;:::i;:::-;10214:74;;10318:30;10314:1;10309:3;10305:11;10298:51;10375:2;10370:3;10366:12;10359:19;;10204:180;;;:::o;10390:325::-;;10553:67;10617:2;10612:3;10553:67;:::i;:::-;10546:74;;10650:29;10646:1;10641:3;10637:11;10630:50;10706:2;10701:3;10697:12;10690:19;;10536:179;;;:::o;10721:368::-;;10884:67;10948:2;10943:3;10884:67;:::i;:::-;10877:74;;10981:34;10977:1;10972:3;10968:11;10961:55;11047:6;11042:2;11037:3;11033:12;11026:28;11080:2;11075:3;11071:12;11064:19;;10867:222;;;:::o;11095:323::-;;11258:67;11322:2;11317:3;11258:67;:::i;:::-;11251:74;;11355:27;11351:1;11346:3;11342:11;11335:48;11409:2;11404:3;11400:12;11393:19;;11241:177;;;:::o;11424:329::-;;11587:67;11651:2;11646:3;11587:67;:::i;:::-;11580:74;;11684:33;11680:1;11675:3;11671:11;11664:54;11744:2;11739:3;11735:12;11728:19;;11570:183;;;:::o;11759:325::-;;11922:67;11986:2;11981:3;11922:67;:::i;:::-;11915:74;;12019:29;12015:1;12010:3;12006:11;11999:50;12075:2;12070:3;12066:12;12059:19;;11905:179;;;:::o;12090:370::-;;12253:67;12317:2;12312:3;12253:67;:::i;:::-;12246:74;;12350:34;12346:1;12341:3;12337:11;12330:55;12416:8;12411:2;12406:3;12402:12;12395:30;12451:2;12446:3;12442:12;12435:19;;12236:224;;;:::o;12466:376::-;;12629:67;12693:2;12688:3;12629:67;:::i;:::-;12622:74;;12726:34;12722:1;12717:3;12713:11;12706:55;12792:14;12787:2;12782:3;12778:12;12771:36;12833:2;12828:3;12824:12;12817:19;;12612:230;;;:::o;12848:388::-;;13011:67;13075:2;13070:3;13011:67;:::i;:::-;13004:74;;13108:34;13104:1;13099:3;13095:11;13088:55;13174:26;13169:2;13164:3;13160:12;13153:48;13227:2;13222:3;13218:12;13211:19;;12994:242;;;:::o;13242:374::-;;13405:67;13469:2;13464:3;13405:67;:::i;:::-;13398:74;;13502:34;13498:1;13493:3;13489:11;13482:55;13568:12;13563:2;13558:3;13554:12;13547:34;13607:2;13602:3;13598:12;13591:19;;13388:228;;;:::o;13622:330::-;;13785:67;13849:2;13844:3;13785:67;:::i;:::-;13778:74;;13882:34;13878:1;13873:3;13869:11;13862:55;13943:2;13938:3;13934:12;13927:19;;13768:184;;;:::o;13958:366::-;;14121:67;14185:2;14180:3;14121:67;:::i;:::-;14114:74;;14218:34;14214:1;14209:3;14205:11;14198:55;14284:4;14279:2;14274:3;14270:12;14263:26;14315:2;14310:3;14306:12;14299:19;;14104:220;;;:::o;14330:330::-;;14493:67;14557:2;14552:3;14493:67;:::i;:::-;14486:74;;14590:34;14586:1;14581:3;14577:11;14570:55;14651:2;14646:3;14642:12;14635:19;;14476:184;;;:::o;14666:365::-;;14829:67;14893:2;14888:3;14829:67;:::i;:::-;14822:74;;14926:34;14922:1;14917:3;14913:11;14906:55;14992:3;14987:2;14982:3;14978:12;14971:25;15022:2;15017:3;15013:12;15006:19;;14812:219;;;:::o;15037:376::-;;15200:67;15264:2;15259:3;15200:67;:::i;:::-;15193:74;;15297:34;15293:1;15288:3;15284:11;15277:55;15363:14;15358:2;15353:3;15349:12;15342:36;15404:2;15399:3;15395:12;15388:19;;15183:230;;;:::o;15419:330::-;;15582:67;15646:2;15641:3;15582:67;:::i;:::-;15575:74;;15679:34;15675:1;15670:3;15666:11;15659:55;15740:2;15735:3;15731:12;15724:19;;15565:184;;;:::o;15755:373::-;;15918:67;15982:2;15977:3;15918:67;:::i;:::-;15911:74;;16015:34;16011:1;16006:3;16002:11;15995:55;16081:11;16076:2;16071:3;16067:12;16060:33;16119:2;16114:3;16110:12;16103:19;;15901:227;;;:::o;16134:379::-;;16297:67;16361:2;16356:3;16297:67;:::i;:::-;16290:74;;16394:34;16390:1;16385:3;16381:11;16374:55;16460:17;16455:2;16450:3;16446:12;16439:39;16504:2;16499:3;16495:12;16488:19;;16280:233;;;:::o;16519:315::-;;16682:67;16746:2;16741:3;16682:67;:::i;:::-;16675:74;;16779:19;16775:1;16770:3;16766:11;16759:40;16825:2;16820:3;16816:12;16809:19;;16665:169;;;:::o;16840:365::-;;17003:67;17067:2;17062:3;17003:67;:::i;:::-;16996:74;;17100:34;17096:1;17091:3;17087:11;17080:55;17166:3;17161:2;17156:3;17152:12;17145:25;17196:2;17191:3;17187:12;17180:19;;16986:219;;;:::o;17211:381::-;;17374:67;17438:2;17433:3;17374:67;:::i;:::-;17367:74;;17471:34;17467:1;17462:3;17458:11;17451:55;17537:19;17532:2;17527:3;17523:12;17516:41;17583:2;17578:3;17574:12;17567:19;;17357:235;;;:::o;17598:327::-;;17761:67;17825:2;17820:3;17761:67;:::i;:::-;17754:74;;17858:31;17854:1;17849:3;17845:11;17838:52;17916:2;17911:3;17907:12;17900:19;;17744:181;;;:::o;17931:329::-;;18094:67;18158:2;18153:3;18094:67;:::i;:::-;18087:74;;18191:33;18187:1;18182:3;18178:11;18171:54;18251:2;18246:3;18242:12;18235:19;;18077:183;;;:::o;18266:365::-;;18429:67;18493:2;18488:3;18429:67;:::i;:::-;18422:74;;18526:34;18522:1;18517:3;18513:11;18506:55;18592:3;18587:2;18582:3;18578:12;18571:25;18622:2;18617:3;18613:12;18606:19;;18412:219;;;:::o;18637:108::-;18714:24;18732:5;18714:24;:::i;:::-;18709:3;18702:37;18692:53;;:::o;18751:118::-;18838:24;18856:5;18838:24;:::i;:::-;18833:3;18826:37;18816:53;;:::o;18875:271::-;;19027:93;19116:3;19107:6;19027:93;:::i;:::-;19020:100;;19137:3;19130:10;;19009:137;;;;:::o;19152:435::-;;19354:95;19445:3;19436:6;19354:95;:::i;:::-;19347:102;;19466:95;19557:3;19548:6;19466:95;:::i;:::-;19459:102;;19578:3;19571:10;;19336:251;;;;;:::o;19593:222::-;;19724:2;19713:9;19709:18;19701:26;;19737:71;19805:1;19794:9;19790:17;19781:6;19737:71;:::i;:::-;19691:124;;;;:::o;19821:672::-;;20070:3;20059:9;20055:19;20047:27;;20084:87;20168:1;20157:9;20153:17;20144:6;20084:87;:::i;:::-;20181:72;20249:2;20238:9;20234:18;20225:6;20181:72;:::i;:::-;20263;20331:2;20320:9;20316:18;20307:6;20263:72;:::i;:::-;20382:9;20376:4;20372:20;20367:2;20356:9;20352:18;20345:48;20410:76;20481:4;20472:6;20410:76;:::i;:::-;20402:84;;20037:456;;;;;;;:::o;20499:373::-;;20680:2;20669:9;20665:18;20657:26;;20729:9;20723:4;20719:20;20715:1;20704:9;20700:17;20693:47;20757:108;20860:4;20851:6;20757:108;:::i;:::-;20749:116;;20647:225;;;;:::o;20878:210::-;;21003:2;20992:9;20988:18;20980:26;;21016:65;21078:1;21067:9;21063:17;21054:6;21016:65;:::i;:::-;20970:118;;;;:::o;21094:313::-;;21245:2;21234:9;21230:18;21222:26;;21294:9;21288:4;21284:20;21280:1;21269:9;21265:17;21258:47;21322:78;21395:4;21386:6;21322:78;:::i;:::-;21314:86;;21212:195;;;;:::o;21413:419::-;;21617:2;21606:9;21602:18;21594:26;;21666:9;21660:4;21656:20;21652:1;21641:9;21637:17;21630:47;21694:131;21820:4;21694:131;:::i;:::-;21686:139;;21584:248;;;:::o;21838:419::-;;22042:2;22031:9;22027:18;22019:26;;22091:9;22085:4;22081:20;22077:1;22066:9;22062:17;22055:47;22119:131;22245:4;22119:131;:::i;:::-;22111:139;;22009:248;;;:::o;22263:419::-;;22467:2;22456:9;22452:18;22444:26;;22516:9;22510:4;22506:20;22502:1;22491:9;22487:17;22480:47;22544:131;22670:4;22544:131;:::i;:::-;22536:139;;22434:248;;;:::o;22688:419::-;;22892:2;22881:9;22877:18;22869:26;;22941:9;22935:4;22931:20;22927:1;22916:9;22912:17;22905:47;22969:131;23095:4;22969:131;:::i;:::-;22961:139;;22859:248;;;:::o;23113:419::-;;23317:2;23306:9;23302:18;23294:26;;23366:9;23360:4;23356:20;23352:1;23341:9;23337:17;23330:47;23394:131;23520:4;23394:131;:::i;:::-;23386:139;;23284:248;;;:::o;23538:419::-;;23742:2;23731:9;23727:18;23719:26;;23791:9;23785:4;23781:20;23777:1;23766:9;23762:17;23755:47;23819:131;23945:4;23819:131;:::i;:::-;23811:139;;23709:248;;;:::o;23963:419::-;;24167:2;24156:9;24152:18;24144:26;;24216:9;24210:4;24206:20;24202:1;24191:9;24187:17;24180:47;24244:131;24370:4;24244:131;:::i;:::-;24236:139;;24134:248;;;:::o;24388:419::-;;24592:2;24581:9;24577:18;24569:26;;24641:9;24635:4;24631:20;24627:1;24616:9;24612:17;24605:47;24669:131;24795:4;24669:131;:::i;:::-;24661:139;;24559:248;;;:::o;24813:419::-;;25017:2;25006:9;25002:18;24994:26;;25066:9;25060:4;25056:20;25052:1;25041:9;25037:17;25030:47;25094:131;25220:4;25094:131;:::i;:::-;25086:139;;24984:248;;;:::o;25238:419::-;;25442:2;25431:9;25427:18;25419:26;;25491:9;25485:4;25481:20;25477:1;25466:9;25462:17;25455:47;25519:131;25645:4;25519:131;:::i;:::-;25511:139;;25409:248;;;:::o;25663:419::-;;25867:2;25856:9;25852:18;25844:26;;25916:9;25910:4;25906:20;25902:1;25891:9;25887:17;25880:47;25944:131;26070:4;25944:131;:::i;:::-;25936:139;;25834:248;;;:::o;26088:419::-;;26292:2;26281:9;26277:18;26269:26;;26341:9;26335:4;26331:20;26327:1;26316:9;26312:17;26305:47;26369:131;26495:4;26369:131;:::i;:::-;26361:139;;26259:248;;;:::o;26513:419::-;;26717:2;26706:9;26702:18;26694:26;;26766:9;26760:4;26756:20;26752:1;26741:9;26737:17;26730:47;26794:131;26920:4;26794:131;:::i;:::-;26786:139;;26684:248;;;:::o;26938:419::-;;27142:2;27131:9;27127:18;27119:26;;27191:9;27185:4;27181:20;27177:1;27166:9;27162:17;27155:47;27219:131;27345:4;27219:131;:::i;:::-;27211:139;;27109:248;;;:::o;27363:419::-;;27567:2;27556:9;27552:18;27544:26;;27616:9;27610:4;27606:20;27602:1;27591:9;27587:17;27580:47;27644:131;27770:4;27644:131;:::i;:::-;27636:139;;27534:248;;;:::o;27788:419::-;;27992:2;27981:9;27977:18;27969:26;;28041:9;28035:4;28031:20;28027:1;28016:9;28012:17;28005:47;28069:131;28195:4;28069:131;:::i;:::-;28061:139;;27959:248;;;:::o;28213:419::-;;28417:2;28406:9;28402:18;28394:26;;28466:9;28460:4;28456:20;28452:1;28441:9;28437:17;28430:47;28494:131;28620:4;28494:131;:::i;:::-;28486:139;;28384:248;;;:::o;28638:419::-;;28842:2;28831:9;28827:18;28819:26;;28891:9;28885:4;28881:20;28877:1;28866:9;28862:17;28855:47;28919:131;29045:4;28919:131;:::i;:::-;28911:139;;28809:248;;;:::o;29063:419::-;;29267:2;29256:9;29252:18;29244:26;;29316:9;29310:4;29306:20;29302:1;29291:9;29287:17;29280:47;29344:131;29470:4;29344:131;:::i;:::-;29336:139;;29234:248;;;:::o;29488:419::-;;29692:2;29681:9;29677:18;29669:26;;29741:9;29735:4;29731:20;29727:1;29716:9;29712:17;29705:47;29769:131;29895:4;29769:131;:::i;:::-;29761:139;;29659:248;;;:::o;29913:419::-;;30117:2;30106:9;30102:18;30094:26;;30166:9;30160:4;30156:20;30152:1;30141:9;30137:17;30130:47;30194:131;30320:4;30194:131;:::i;:::-;30186:139;;30084:248;;;:::o;30338:419::-;;30542:2;30531:9;30527:18;30519:26;;30591:9;30585:4;30581:20;30577:1;30566:9;30562:17;30555:47;30619:131;30745:4;30619:131;:::i;:::-;30611:139;;30509:248;;;:::o;30763:419::-;;30967:2;30956:9;30952:18;30944:26;;31016:9;31010:4;31006:20;31002:1;30991:9;30987:17;30980:47;31044:131;31170:4;31044:131;:::i;:::-;31036:139;;30934:248;;;:::o;31188:419::-;;31392:2;31381:9;31377:18;31369:26;;31441:9;31435:4;31431:20;31427:1;31416:9;31412:17;31405:47;31469:131;31595:4;31469:131;:::i;:::-;31461:139;;31359:248;;;:::o;31613:419::-;;31817:2;31806:9;31802:18;31794:26;;31866:9;31860:4;31856:20;31852:1;31841:9;31837:17;31830:47;31894:131;32020:4;31894:131;:::i;:::-;31886:139;;31784:248;;;:::o;32038:419::-;;32242:2;32231:9;32227:18;32219:26;;32291:9;32285:4;32281:20;32277:1;32266:9;32262:17;32255:47;32319:131;32445:4;32319:131;:::i;:::-;32311:139;;32209:248;;;:::o;32463:419::-;;32667:2;32656:9;32652:18;32644:26;;32716:9;32710:4;32706:20;32702:1;32691:9;32687:17;32680:47;32744:131;32870:4;32744:131;:::i;:::-;32736:139;;32634:248;;;:::o;32888:222::-;;33019:2;33008:9;33004:18;32996:26;;33032:71;33100:1;33089:9;33085:17;33076:6;33032:71;:::i;:::-;32986:124;;;;:::o;33116:278::-;;33182:2;33176:9;33166:19;;33224:4;33216:6;33212:17;33331:6;33319:10;33316:22;33295:18;33283:10;33280:34;33277:62;33274:2;;;33342:13;;:::i;:::-;33274:2;33377:10;33373:2;33366:22;33156:238;;;;:::o;33400:326::-;;33551:18;33543:6;33540:30;33537:2;;;33573:13;;:::i;:::-;33537:2;33653:4;33649:9;33642:4;33634:6;33630:17;33626:33;33618:41;;33714:4;33708;33704:15;33696:23;;33466:260;;;:::o;33732:327::-;;33884:18;33876:6;33873:30;33870:2;;;33906:13;;:::i;:::-;33870:2;33986:4;33982:9;33975:4;33967:6;33963:17;33959:33;33951:41;;34047:4;34041;34037:15;34029:23;;33799:260;;;:::o;34065:132::-;;34155:3;34147:11;;34185:4;34180:3;34176:14;34168:22;;34137:60;;;:::o;34203:114::-;;34304:5;34298:12;34288:22;;34277:40;;;:::o;34323:98::-;;34408:5;34402:12;34392:22;;34381:40;;;:::o;34427:99::-;;34513:5;34507:12;34497:22;;34486:40;;;:::o;34532:113::-;;34634:4;34629:3;34625:14;34617:22;;34607:38;;;:::o;34651:184::-;;34784:6;34779:3;34772:19;34824:4;34819:3;34815:14;34800:29;;34762:73;;;;:::o;34841:168::-;;34958:6;34953:3;34946:19;34998:4;34993:3;34989:14;34974:29;;34936:73;;;;:::o;35015:147::-;;35153:3;35138:18;;35128:34;;;;:::o;35168:169::-;;35286:6;35281:3;35274:19;35326:4;35321:3;35317:14;35302:29;;35264:73;;;;:::o;35343:148::-;;35482:3;35467:18;;35457:34;;;;:::o;35497:96::-;;35563:24;35581:5;35563:24;:::i;:::-;35552:35;;35542:51;;;:::o;35599:104::-;;35673:24;35691:5;35673:24;:::i;:::-;35662:35;;35652:51;;;:::o;35709:90::-;;35786:5;35779:13;35772:21;35761:32;;35751:48;;;:::o;35805:149::-;;35881:66;35874:5;35870:78;35859:89;;35849:105;;;:::o;35960:126::-;;36037:42;36030:5;36026:54;36015:65;;36005:81;;;:::o;36092:77::-;;36158:5;36147:16;;36137:32;;;:::o;36175:154::-;36259:6;36254:3;36249;36236:30;36321:1;36312:6;36307:3;36303:16;36296:27;36226:103;;;:::o;36335:307::-;36403:1;36413:113;36427:6;36424:1;36421:13;36413:113;;;36512:1;36507:3;36503:11;36497:18;36493:1;36488:3;36484:11;36477:39;36449:2;36446:1;36442:10;36437:15;;36413:113;;;36544:6;36541:1;36538:13;36535:2;;;36624:1;36615:6;36610:3;36606:16;36599:27;36535:2;36384:258;;;;:::o;36648:48::-;36681:9;36702:102;;36794:2;36790:7;36785:2;36778:5;36774:14;36770:28;36760:38;;36750:54;;;:::o;36810:122::-;36883:24;36901:5;36883:24;:::i;:::-;36876:5;36873:35;36863:2;;36922:1;36919;36912:12;36863:2;36853:79;:::o;36938:116::-;37008:21;37023:5;37008:21;:::i;:::-;37001:5;36998:32;36988:2;;37044:1;37041;37034:12;36988:2;36978:76;:::o;37060:120::-;37132:23;37149:5;37132:23;:::i;:::-;37125:5;37122:34;37112:2;;37170:1;37167;37160:12;37112:2;37102:78;:::o;37186:122::-;37259:24;37277:5;37259:24;:::i;:::-;37252:5;37249:35;37239:2;;37298:1;37295;37288:12;37239:2;37229:79;:::o

Swarm Source

ipfs://497de4cf4f69a6f7151b2af52ade0946593c8917de27ff9f4fe8782264a6b9cf

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.

Tools & Services