Token

ERC-20: HomelessCard (HomelessCard)

ERC-721

Overview

Max Total Supply

462 HomelessCard

Holders

462

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xdcce8175be97986523f27b46c88bde822ef73e6a

Filtered by Token Holder

0x7A5EEcBef4DEC2533D81A7535A9C57B74Ef1EBD1

Balance

1 HomelessCard

0x7a5eecbef4dec2533d81a7535a9c57b74ef1ebd1

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Similar Match Source Code
This contract matches the deployed Bytecode of the Source Code for Contract 0x56Bd2ca9...3146aD238
The constructor portion of the code might be different and could alter the actual behaviour of the contract

Contract Name:

HomelessCard

Compiler Version

v0.8.17+commit.8df45f5f

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-07-10
*/

// Sources flattened with hardhat v2.12.3 https://hardhat.org

// File @openzeppelin/contracts/utils/introspection/[email protected]

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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


// File @solvprotocol/erc-3525/[email protected]

// 

pragma solidity ^0.8.1;

/** 
 * @title ERC-721 Non-Fungible Token Standard
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 *  Note: the ERC-165 identifier for this interface is 0x80ac58cd.
 */
interface IERC721 is IERC165 {
    /** 
     * @dev This emits when ownership of any NFT changes by any mechanism.
     *  This event emits when NFTs are created (`from` == 0) and destroyed
     *  (`to` == 0). Exception: during contract creation, any number of NFTs
     *  may be created and assigned without emitting Transfer. At the time of
     *  any transfer, the approved address for that NFT (if any) is reset to none.
     */
    event Transfer(address indexed _from, address indexed _to, uint256 indexed _tokenId);

    /**
     * @dev This emits when the approved address for an NFT is changed or
     *  reaffirmed. The zero address indicates there is no approved address.
     *  When a Transfer event emits, this also indicates that the approved
     *  address for that NFT (if any) is reset to none.
     */
    event Approval(address indexed _owner, address indexed _approved, uint256 indexed _tokenId);

    /**
     * @dev This emits when an operator is enabled or disabled for an owner.
     *  The operator can manage all NFTs of the owner.
     */
    event ApprovalForAll(address indexed _owner, address indexed _operator, bool _approved);

    /**
     * @notice Count all NFTs assigned to an owner
     * @dev NFTs assigned to the zero address are considered invalid, and this
     *  function throws for queries about the zero address.
     * @param _owner An address for whom to query the balance
     * @return The number of NFTs owned by `_owner`, possibly zero
     */
    function balanceOf(address _owner) external view returns (uint256);

    /**
     * @notice Find the owner of an NFT
     * @dev NFTs assigned to zero address are considered invalid, and queries
     *  about them do throw.
     * @param _tokenId The identifier for an NFT
     * @return The address of the owner of the NFT
     */
    function ownerOf(uint256 _tokenId) external view returns (address);

    /**
     * @notice Transfers the ownership of an NFT from one address to another address
     * @dev Throws unless `msg.sender` is the current owner, an authorized
     *  operator, or the approved address for this NFT. Throws if `_from` is
     *  not the current owner. Throws if `_to` is the zero address. Throws if
     *  `_tokenId` is not a valid NFT. When transfer is complete, this function
     *  checks if `_to` is a smart contract (code size > 0). If so, it calls
     *  `onERC721Received` on `_to` and throws if the return value is not
     *  `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
     * @param _from The current owner of the NFT
     * @param _to The new owner
     * @param _tokenId The NFT to transfer
     * @param data Additional data with no specified format, sent in call to `_to`
     */
    function safeTransferFrom(address _from, address _to, uint256 _tokenId, bytes calldata data) external payable;

    /**
     * @notice Transfers the ownership of an NFT from one address to another address
     * @dev This works identically to the other function with an extra data parameter,
     *  except this function just sets data to "".
     * @param _from The current owner of the NFT
     * @param _to The new owner
     * @param _tokenId The NFT to transfer
     */
    function safeTransferFrom(address _from, address _to, uint256 _tokenId) external payable;

    /**
     * @notice Transfer ownership of an NFT -- THE CALLER IS RESPONSIBLE
     *  TO CONFIRM THAT `_to` IS CAPABLE OF RECEIVING NFTS OR ELSE
     *  THEY MAY BE PERMANENTLY LOST
     * @dev Throws unless `msg.sender` is the current owner, an authorized
     *  operator, or the approved address for this NFT. Throws if `_from` is
     *  not the current owner. Throws if `_to` is the zero address. Throws if
     *  `_tokenId` is not a valid NFT.
     * @param _from The current owner of the NFT
     * @param _to The new owner
     * @param _tokenId The NFT to transfer
     */
    function transferFrom(address _from, address _to, uint256 _tokenId) external payable;

    /**
     * @notice Change or reaffirm the approved address for an NFT
     * @dev The zero address indicates there is no approved address.
     *  Throws unless `msg.sender` is the current NFT owner, or an authorized
     *  operator of the current owner.
     * @param _approved The new approved NFT controller
     * @param _tokenId The NFT to approve
     */
    function approve(address _approved, uint256 _tokenId) external payable;

    /**
     * @notice Enable or disable approval for a third party ("operator") to manage
     *  all of `msg.sender`'s assets
     * @dev Emits the ApprovalForAll event. The contract MUST allow
     *  multiple operators per owner.
     * @param _operator Address to add to the set of authorized operators
     * @param _approved True if the operator is approved, false to revoke approval
     */
    function setApprovalForAll(address _operator, bool _approved) external;

    /**
     * @notice Get the approved address for a single NFT
     * @dev Throws if `_tokenId` is not a valid NFT.
     * @param _tokenId The NFT to find the approved address for
     * @return The approved address for this NFT, or the zero address if there is none
     */
    function getApproved(uint256 _tokenId) external view returns (address);

    /**
     * @notice Query if an address is an authorized operator for another address
     * @param _owner The address that owns the NFTs
     * @param _operator The address that acts on behalf of the owner
     * @return True if `_operator` is an approved operator for `_owner`, false otherwise
     */
    function isApprovedForAll(address _owner, address _operator) external view returns (bool);
}


// File @solvprotocol/erc-3525/[email protected]

// 

pragma solidity ^0.8.0;


/**
 * @title ERC-3525 Semi-Fungible Token Standard
 * @dev See https://eips.ethereum.org/EIPS/eip-3525
 * Note: the ERC-165 identifier for this interface is 0xd5358140.
 */
interface IERC3525 is IERC165, IERC721 {
    /**
     * @dev MUST emit when value of a token is transferred to another token with the same slot,
     *  including zero value transfers (_value == 0) as well as transfers when tokens are created
     *  (`_fromTokenId` == 0) or destroyed (`_toTokenId` == 0).
     * @param _fromTokenId The token id to transfer value from
     * @param _toTokenId The token id to transfer value to
     * @param _value The transferred value
     */
    event TransferValue(uint256 indexed _fromTokenId, uint256 indexed _toTokenId, uint256 _value);

    /**
     * @dev MUST emits when the approval value of a token is set or changed.
     * @param _tokenId The token to approve
     * @param _operator The operator to approve for
     * @param _value The maximum value that `_operator` is allowed to manage
     */
    event ApprovalValue(uint256 indexed _tokenId, address indexed _operator, uint256 _value);

    /**
     * @dev MUST emit when the slot of a token is set or changed.
     * @param _tokenId The token of which slot is set or changed
     * @param _oldSlot The previous slot of the token
     * @param _newSlot The updated slot of the token
     */ 
    event SlotChanged(uint256 indexed _tokenId, uint256 indexed _oldSlot, uint256 indexed _newSlot);

    /**
     * @notice Get the number of decimals the token uses for value - e.g. 6, means the user
     *  representation of the value of a token can be calculated by dividing it by 1,000,000.
     *  Considering the compatibility with third-party wallets, this function is defined as
     *  `valueDecimals()` instead of `decimals()` to avoid conflict with ERC20 tokens.
     * @return The number of decimals for value
     */
    function valueDecimals() external view returns (uint8);

    /**
     * @notice Get the value of a token.
     * @param _tokenId The token for which to query the balance
     * @return The value of `_tokenId`
     */
    function balanceOf(uint256 _tokenId) external view returns (uint256);

    /**
     * @notice Get the slot of a token.
     * @param _tokenId The identifier for a token
     * @return The slot of the token
     */
    function slotOf(uint256 _tokenId) external view returns (uint256);

    /**
     * @notice Allow an operator to manage the value of a token, up to the `_value` amount.
     * @dev MUST revert unless caller is the current owner, an authorized operator, or the approved
     *  address for `_tokenId`.
     *  MUST emit ApprovalValue event.
     * @param _tokenId The token to approve
     * @param _operator The operator to be approved
     * @param _value The maximum value of `_toTokenId` that `_operator` is allowed to manage
     */
    function approve(
        uint256 _tokenId,
        address _operator,
        uint256 _value
    ) external payable;

    /**
     * @notice Get the maximum value of a token that an operator is allowed to manage.
     * @param _tokenId The token for which to query the allowance
     * @param _operator The address of an operator
     * @return The current approval value of `_tokenId` that `_operator` is allowed to manage
     */
    function allowance(uint256 _tokenId, address _operator) external view returns (uint256);

    /**
     * @notice Transfer value from a specified token to another specified token with the same slot.
     * @dev Caller MUST be the current owner, an authorized operator or an operator who has been
     *  approved the whole `_fromTokenId` or part of it.
     *  MUST revert if `_fromTokenId` or `_toTokenId` is zero token id or does not exist.
     *  MUST revert if slots of `_fromTokenId` and `_toTokenId` do not match.
     *  MUST revert if `_value` exceeds the balance of `_fromTokenId` or its allowance to the
     *  operator.
     *  MUST emit `TransferValue` event.
     * @param _fromTokenId The token to transfer value from
     * @param _toTokenId The token to transfer value to
     * @param _value The transferred value
     */
    function transferFrom(
        uint256 _fromTokenId,
        uint256 _toTokenId,
        uint256 _value
    ) external payable;

    /**
     * @notice Transfer value from a specified token to an address. The caller should confirm that
     *  `_to` is capable of receiving ERC3525 tokens.
     * @dev This function MUST create a new ERC3525 token with the same slot for `_to` to receive
     *  the transferred value.
     *  MUST revert if `_fromTokenId` is zero token id or does not exist.
     *  MUST revert if `_to` is zero address.
     *  MUST revert if `_value` exceeds the balance of `_fromTokenId` or its allowance to the
     *  operator.
     *  MUST emit `Transfer` and `TransferValue` events.
     * @param _fromTokenId The token to transfer value from
     * @param _to The address to transfer value to
     * @param _value The transferred value
     * @return ID of the new token created for `_to` which receives the transferred value
     */
    function transferFrom(
        uint256 _fromTokenId,
        address _to,
        uint256 _value
    ) external payable returns (uint256);
}


// File @solvprotocol/erc-3525/[email protected]

// 

pragma solidity ^0.8.1;

/**
 * @title EIP-3525 token receiver interface
 * @dev Interface for a smart contract that wants to be informed by EIP-3525 contracts when 
 *  receiving values from ANY addresses or EIP-3525 tokens.
 * Note: the EIP-165 identifier for this interface is 0x009ce20b.
 */
interface IERC3525Receiver {
    /**
     * @notice Handle the receipt of an EIP-3525 token value.
     * @dev An EIP-3525 smart contract MUST check whether this function is implemented by the 
     *  recipient contract, if the recipient contract implements this function, the EIP-3525 
     *  contract MUST call this function after a value transfer (i.e. `transferFrom(uint256,
     *  uint256,uint256,bytes)`).
     *  MUST return 0x009ce20b (i.e. `bytes4(keccak256('onERC3525Received(address,uint256,uint256,
     *  uint256,bytes)'))`) if the transfer is accepted.
     *  MUST revert or return any value other than 0x009ce20b if the transfer is rejected.
     * @param _operator The address which triggered the transfer
     * @param _fromTokenId The token id to transfer value from
     * @param _toTokenId The token id to transfer value to
     * @param _value The transferred value
     * @param _data Additional data with no specified format
     * @return `bytes4(keccak256('onERC3525Received(address,uint256,uint256,uint256,bytes)'))` 
     *  unless the transfer is rejected.
     */
    function onERC3525Received(address _operator, uint256 _fromTokenId, uint256 _toTokenId, uint256 _value, bytes calldata _data) external returns (bytes4);

}


// File @solvprotocol/erc-3525/[email protected]

// 

pragma solidity ^0.8.1;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers from ERC721 asset contracts.
 *  Note: the ERC-165 identifier for this interface is 0x150b7a02.
 */
interface IERC721Receiver {
    /** 
     * @notice Handle the receipt of an NFT
     * @dev The ERC721 smart contract calls this function on the recipient
     *  after a `transfer`. This function MAY throw to revert and reject the
     *  transfer. Return of other than the magic value MUST result in the
     *  transaction being reverted.
     *  Note: the contract address is always the message sender.
     * @param _operator The address which called `safeTransferFrom` function
     * @param _from The address which previously owned the token
     * @param _tokenId The NFT identifier which is being transferred
     * @param _data Additional data with no specified format
     * @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
     *  unless throwing
     */
    function onERC721Received(
        address _operator, 
        address _from, 
        uint256 _tokenId, 
        bytes calldata _data
    ) external returns(bytes4);
}


// File @openzeppelin/contracts/utils/[email protected]

// 
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]

// 
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard signed math utilities missing in the Solidity language.
 */
library SignedMath {
    /**
     * @dev Returns the largest of two signed numbers.
     */
    function max(int256 a, int256 b) internal pure returns (int256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two signed numbers.
     */
    function min(int256 a, int256 b) internal pure returns (int256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}


// File @openzeppelin/contracts/utils/math/[email protected]

// 
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a > b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]

// 
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;


/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}


// File @openzeppelin/contracts/utils/[email protected]

// 
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}


// File @solvprotocol/erc-3525/extensions/[email protected]

// 

pragma solidity ^0.8.1;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 *  Note: the ERC-165 identifier for this interface is 0x780e9d63.
 */
interface IERC721Enumerable is IERC721 {
    /** 
     * @notice Count NFTs tracked by this contract
     * @return A count of valid NFTs tracked by this contract, where each one of
     *  them has an assigned and queryable owner not equal to the zero address
     */
    function totalSupply() external view returns (uint256);

    /** 
     * @notice Enumerate valid NFTs
     * @dev Throws if `_index` >= `totalSupply()`.
     * @param _index A counter less than `totalSupply()`
     * @return The token identifier for the `_index`th NFT,
     *  (sort order not specified)
     */
    function tokenByIndex(uint256 _index) external view returns (uint256);

    /** 
     * @notice Enumerate NFTs assigned to an owner
     * @dev Throws if `_index` >= `balanceOf(_owner)` or if
     *  `_owner` is the zero address, representing invalid NFTs.
     * @param _owner An address where we are interested in NFTs owned by them
     * @param _index A counter less than `balanceOf(_owner)`
     * @return The token identifier for the `_index`th NFT assigned to `_owner`,
     *  (sort order not specified)
     */
    function tokenOfOwnerByIndex(address _owner, uint256 _index) external view returns (uint256);
}


// File @solvprotocol/erc-3525/extensions/[email protected]

// 

pragma solidity ^0.8.1;

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 *  Note: the ERC-165 identifier for this interface is 0x5b5e139f.
 */
interface IERC721Metadata is IERC721 {
    /**
     * @notice A descriptive name for a collection of NFTs in this contract
     */
    function name() external view returns (string memory);

    /**
     * @notice An abbreviated name for NFTs in this contract
     */
    function symbol() external view returns (string memory);

    /**
     * @notice A distinct Uniform Resource Identifier (URI) for a given asset.
     * @dev Throws if `_tokenId` is not a valid NFT. URIs are defined in RFC
     *  3986. The URI may point to a JSON file that conforms to the "ERC721
     *  Metadata JSON Schema".
     */
    function tokenURI(uint256 _tokenId) external view returns (string memory);
}


// File @openzeppelin/contracts/utils/[email protected]

// 
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://consensys.net/diligence/blog/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.8.0/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}


// File @solvprotocol/erc-3525/extensions/[email protected]

// 

pragma solidity ^0.8.1;


/**
 * @title ERC-3525 Semi-Fungible Token Standard, optional extension for metadata
 * @dev Interfaces for any contract that wants to support query of the Uniform Resource Identifier
 *  (URI) for the ERC3525 contract as well as a specified slot.
 *  Because of the higher reliability of data stored in smart contracts compared to data stored in
 *  centralized systems, it is recommended that metadata, including `contractURI`, `slotURI` and
 *  `tokenURI`, be directly returned in JSON format, instead of being returned with a url pointing
 *  to any resource stored in a centralized system.
 *  See https://eips.ethereum.org/EIPS/eip-3525
 * Note: the ERC-165 identifier for this interface is 0xe1600902.
 */
interface IERC3525Metadata is IERC3525, IERC721Metadata {
    /**
     * @notice Returns the Uniform Resource Identifier (URI) for the current ERC3525 contract.
     * @dev This function SHOULD return the URI for this contract in JSON format, starting with
     *  header `data:application/json;`.
     *  See https://eips.ethereum.org/EIPS/eip-3525 for the JSON schema for contract URI.
     * @return The JSON formatted URI of the current ERC3525 contract
     */
    function contractURI() external view returns (string memory);

    /**
     * @notice Returns the Uniform Resource Identifier (URI) for the specified slot.
     * @dev This function SHOULD return the URI for `_slot` in JSON format, starting with header
     *  `data:application/json;`.
     *  See https://eips.ethereum.org/EIPS/eip-3525 for the JSON schema for slot URI.
     * @return The JSON formatted URI of `_slot`
     */
    function slotURI(uint256 _slot) external view returns (string memory);
}


// File @solvprotocol/erc-3525/periphery/interface/[email protected]

// 

pragma solidity ^0.8.0;

interface IERC3525MetadataDescriptor {

    function constructContractURI() external view returns (string memory);

    function constructSlotURI(uint256 slot) external view returns (string memory);
    
    function constructTokenURI(uint256 tokenId) external view returns (string memory);

}


// File @solvprotocol/erc-3525/[email protected]

// 

pragma solidity ^0.8.0;













contract ERC3525 is Context, IERC3525Metadata, IERC721Enumerable {
    using Strings for address;
    using Strings for uint256;
    using Address for address;
    using Counters for Counters.Counter;

    event SetMetadataDescriptor(address indexed metadataDescriptor);

    struct TokenData {
        uint256 id;
        uint256 slot;
        uint256 balance;
        address owner;
        address approved;
        address[] valueApprovals;
    }

    struct AddressData {
        uint256[] ownedTokens;
        mapping(uint256 => uint256) ownedTokensIndex;
        mapping(address => bool) approvals;
    }

    string private _name;
    string private _symbol;
    uint8 private _decimals;
    Counters.Counter private _tokenIdGenerator;

    // id => (approval => allowance)
    // @dev _approvedValues cannot be defined within TokenData, cause struct containing mappings cannot be constructed.
    mapping(uint256 => mapping(address => uint256)) private _approvedValues;

    TokenData[] private _allTokens;

    // key: id
    mapping(uint256 => uint256) private _allTokensIndex;

    mapping(address => AddressData) private _addressData;

    IERC3525MetadataDescriptor public metadataDescriptor;

    constructor(string memory name_, string memory symbol_, uint8 decimals_) {
         _name = name_;
        _symbol = symbol_;
        _decimals = decimals_;
    }

    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return
            interfaceId == type(IERC165).interfaceId ||
            interfaceId == type(IERC3525).interfaceId ||
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC3525Metadata).interfaceId ||
            interfaceId == type(IERC721Enumerable).interfaceId || 
            interfaceId == type(IERC721Metadata).interfaceId;
    }

    /**
     * @dev Returns the token collection name.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals the token uses for value.
     */
    function valueDecimals() public view virtual override returns (uint8) {
        return _decimals;
    }

    function balanceOf(uint256 tokenId_) public view virtual override returns (uint256) {
        _requireMinted(tokenId_);
        return _allTokens[_allTokensIndex[tokenId_]].balance;
    }

    function ownerOf(uint256 tokenId_) public view virtual override returns (address owner_) {
        _requireMinted(tokenId_);
        owner_ = _allTokens[_allTokensIndex[tokenId_]].owner;
        require(owner_ != address(0), "ERC3525: invalid token ID");
    }

    function slotOf(uint256 tokenId_) public view virtual override returns (uint256) {
        _requireMinted(tokenId_);
        return _allTokens[_allTokensIndex[tokenId_]].slot;
    }

    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    function contractURI() public view virtual override returns (string memory) {
        string memory baseURI = _baseURI();
        return 
            address(metadataDescriptor) != address(0) ? 
                metadataDescriptor.constructContractURI() :
                bytes(baseURI).length > 0 ? 
                    string(abi.encodePacked(baseURI, "contract/", Strings.toHexString(address(this)))) : 
                    "";
    }

    function slotURI(uint256 slot_) public view virtual override returns (string memory) {
        string memory baseURI = _baseURI();
        return 
            address(metadataDescriptor) != address(0) ? 
                metadataDescriptor.constructSlotURI(slot_) : 
                bytes(baseURI).length > 0 ? 
                    string(abi.encodePacked(baseURI, "slot/", slot_.toString())) : 
                    "";
    }

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId_) public view virtual override returns (string memory) {
        _requireMinted(tokenId_);
        string memory baseURI = _baseURI();
        return 
            address(metadataDescriptor) != address(0) ? 
                metadataDescriptor.constructTokenURI(tokenId_) : 
                bytes(baseURI).length > 0 ? 
                    string(abi.encodePacked(baseURI, tokenId_.toString())) : 
                    "";
    }

    function approve(uint256 tokenId_, address to_, uint256 value_) public payable virtual override {
        address owner = ERC3525.ownerOf(tokenId_);
        require(to_ != owner, "ERC3525: approval to current owner");

        require(_isApprovedOrOwner(_msgSender(), tokenId_), "ERC3525: approve caller is not owner nor approved");

        _approveValue(tokenId_, to_, value_);
    }

    function allowance(uint256 tokenId_, address operator_) public view virtual override returns (uint256) {
        _requireMinted(tokenId_);
        return _approvedValues[tokenId_][operator_];
    }

    function transferFrom(
        uint256 fromTokenId_,
        address to_,
        uint256 value_
    ) public payable virtual override returns (uint256 newTokenId) {
        _spendAllowance(_msgSender(), fromTokenId_, value_);

        newTokenId = _createDerivedTokenId(fromTokenId_);
        _mint(to_, newTokenId, ERC3525.slotOf(fromTokenId_), 0);
        _transferValue(fromTokenId_, newTokenId, value_);
    }

    function transferFrom(
        uint256 fromTokenId_,
        uint256 toTokenId_,
        uint256 value_
    ) public payable virtual override {
        _spendAllowance(_msgSender(), fromTokenId_, value_);
        _transferValue(fromTokenId_, toTokenId_, value_);
    }

    function balanceOf(address owner_) public view virtual override returns (uint256 balance) {
        require(owner_ != address(0), "ERC3525: balance query for the zero address");
        return _addressData[owner_].ownedTokens.length;
    }

    function transferFrom(
        address from_,
        address to_,
        uint256 tokenId_
    ) public payable virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId_), "ERC3525: transfer caller is not owner nor approved");
        _transferTokenId(from_, to_, tokenId_);
    }

    function safeTransferFrom(
        address from_,
        address to_,
        uint256 tokenId_,
        bytes memory data_
    ) public payable virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId_), "ERC3525: transfer caller is not owner nor approved");
        _safeTransferTokenId(from_, to_, tokenId_, data_);
    }

    function safeTransferFrom(
        address from_,
        address to_,
        uint256 tokenId_
    ) public payable virtual override {
        safeTransferFrom(from_, to_, tokenId_, "");
    }

    function approve(address to_, uint256 tokenId_) public payable virtual override {
        address owner = ERC3525.ownerOf(tokenId_);
        require(to_ != owner, "ERC3525: approval to current owner");

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

        _approve(to_, tokenId_);
    }

    function getApproved(uint256 tokenId_) public view virtual override returns (address) {
        _requireMinted(tokenId_);
        return _allTokens[_allTokensIndex[tokenId_]].approved;
    }

    function setApprovalForAll(address operator_, bool approved_) public virtual override {
        _setApprovalForAll(_msgSender(), operator_, approved_);
    }

    function isApprovedForAll(address owner_, address operator_) public view virtual override returns (bool) {
        return _addressData[owner_].approvals[operator_];
    }

    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    function tokenByIndex(uint256 index_) public view virtual override returns (uint256) {
        require(index_ < ERC3525.totalSupply(), "ERC3525: global index out of bounds");
        return _allTokens[index_].id;
    }

    function tokenOfOwnerByIndex(address owner_, uint256 index_) public view virtual override returns (uint256) {
        require(index_ < ERC3525.balanceOf(owner_), "ERC3525: owner index out of bounds");
        return _addressData[owner_].ownedTokens[index_];
    }

    function _setApprovalForAll(
        address owner_,
        address operator_,
        bool approved_
    ) internal virtual {
        require(owner_ != operator_, "ERC3525: approve to caller");

        _addressData[owner_].approvals[operator_] = approved_;

        emit ApprovalForAll(owner_, operator_, approved_);
    }

    function _isApprovedOrOwner(address operator_, uint256 tokenId_) internal view virtual returns (bool) {
        address owner = ERC3525.ownerOf(tokenId_);
        return (
            operator_ == owner ||
            ERC3525.isApprovedForAll(owner, operator_) ||
            ERC3525.getApproved(tokenId_) == operator_
        );
    }

    function _spendAllowance(address operator_, uint256 tokenId_, uint256 value_) internal virtual {
        uint256 currentAllowance = ERC3525.allowance(tokenId_, operator_);
        if (!_isApprovedOrOwner(operator_, tokenId_) && currentAllowance != type(uint256).max) {
            require(currentAllowance >= value_, "ERC3525: insufficient allowance");
            _approveValue(tokenId_, operator_, currentAllowance - value_);
        }
    }

    function _exists(uint256 tokenId_) internal view virtual returns (bool) {
        return _allTokens.length != 0 && _allTokens[_allTokensIndex[tokenId_]].id == tokenId_;
    }

    function _requireMinted(uint256 tokenId_) internal view virtual {
        require(_exists(tokenId_), "ERC3525: invalid token ID");
    }

    function _mint(address to_, uint256 slot_, uint256 value_) internal virtual returns (uint256 tokenId) {
        tokenId = _createOriginalTokenId();
        _mint(to_, tokenId, slot_, value_);  
    }

    function _mint(address to_, uint256 tokenId_, uint256 slot_, uint256 value_) internal virtual {
        require(to_ != address(0), "ERC3525: mint to the zero address");
        require(tokenId_ != 0, "ERC3525: cannot mint zero tokenId");
        require(!_exists(tokenId_), "ERC3525: token already minted");

        _beforeValueTransfer(address(0), to_, 0, tokenId_, slot_, value_);
        __mintToken(to_, tokenId_, slot_);
        __mintValue(tokenId_, value_);
        _afterValueTransfer(address(0), to_, 0, tokenId_, slot_, value_);
    }

    function _mintValue(uint256 tokenId_, uint256 value_) internal virtual {
        address owner = ERC3525.ownerOf(tokenId_);
        uint256 slot = ERC3525.slotOf(tokenId_);
        _beforeValueTransfer(address(0), owner, 0, tokenId_, slot, value_);
        __mintValue(tokenId_, value_);
        _afterValueTransfer(address(0), owner, 0, tokenId_, slot, value_);
    }

    function __mintValue(uint256 tokenId_, uint256 value_) private {
        _allTokens[_allTokensIndex[tokenId_]].balance += value_;
        emit TransferValue(0, tokenId_, value_);
    }

    function __mintToken(address to_, uint256 tokenId_, uint256 slot_) private {
        TokenData memory tokenData = TokenData({
            id: tokenId_,
            slot: slot_,
            balance: 0,
            owner: to_,
            approved: address(0),
            valueApprovals: new address[](0)
        });

        _addTokenToAllTokensEnumeration(tokenData);
        _addTokenToOwnerEnumeration(to_, tokenId_);

        emit Transfer(address(0), to_, tokenId_);
        emit SlotChanged(tokenId_, 0, slot_);
    }

    function _burn(uint256 tokenId_) internal virtual {
        _requireMinted(tokenId_);

        TokenData storage tokenData = _allTokens[_allTokensIndex[tokenId_]];
        address owner = tokenData.owner;
        uint256 slot = tokenData.slot;
        uint256 value = tokenData.balance;

        _beforeValueTransfer(owner, address(0), tokenId_, 0, slot, value);

        _clearApprovedValues(tokenId_);
        _removeTokenFromOwnerEnumeration(owner, tokenId_);
        _removeTokenFromAllTokensEnumeration(tokenId_);

        emit TransferValue(tokenId_, 0, value);
        emit SlotChanged(tokenId_, slot, 0);
        emit Transfer(owner, address(0), tokenId_);

        _afterValueTransfer(owner, address(0), tokenId_, 0, slot, value);
    }

    function _burnValue(uint256 tokenId_, uint256 burnValue_) internal virtual {
        _requireMinted(tokenId_);

        TokenData storage tokenData = _allTokens[_allTokensIndex[tokenId_]];
        address owner = tokenData.owner;
        uint256 slot = tokenData.slot;
        uint256 value = tokenData.balance;

        require(value >= burnValue_, "ERC3525: burn value exceeds balance");

        _beforeValueTransfer(owner, address(0), tokenId_, 0, slot, burnValue_);
        
        tokenData.balance -= burnValue_;
        emit TransferValue(tokenId_, 0, burnValue_);
        
        _afterValueTransfer(owner, address(0), tokenId_, 0, slot, burnValue_);
    }

    function _addTokenToOwnerEnumeration(address to_, uint256 tokenId_) private {
        _allTokens[_allTokensIndex[tokenId_]].owner = to_;

        _addressData[to_].ownedTokensIndex[tokenId_] = _addressData[to_].ownedTokens.length;
        _addressData[to_].ownedTokens.push(tokenId_);
    }

    function _removeTokenFromOwnerEnumeration(address from_, uint256 tokenId_) private {
        _allTokens[_allTokensIndex[tokenId_]].owner = address(0);

        AddressData storage ownerData = _addressData[from_];
        uint256 lastTokenIndex = ownerData.ownedTokens.length - 1;
        uint256 lastTokenId = ownerData.ownedTokens[lastTokenIndex];
        uint256 tokenIndex = ownerData.ownedTokensIndex[tokenId_];

        ownerData.ownedTokens[tokenIndex] = lastTokenId;
        ownerData.ownedTokensIndex[lastTokenId] = tokenIndex;

        delete ownerData.ownedTokensIndex[tokenId_];
        ownerData.ownedTokens.pop();
    }

    function _addTokenToAllTokensEnumeration(TokenData memory tokenData_) private {
        _allTokensIndex[tokenData_.id] = _allTokens.length;
        _allTokens.push(tokenData_);
    }

    function _removeTokenFromAllTokensEnumeration(uint256 tokenId_) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId_];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        TokenData memory lastTokenData = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenData; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenData.id] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId_];
        _allTokens.pop();
    }

    function _approve(address to_, uint256 tokenId_) internal virtual {
        _allTokens[_allTokensIndex[tokenId_]].approved = to_;
        emit Approval(ERC3525.ownerOf(tokenId_), to_, tokenId_);
    }

    function _approveValue(
        uint256 tokenId_,
        address to_,
        uint256 value_
    ) internal virtual {
        require(to_ != address(0), "ERC3525: approve value to the zero address");
        if (!_existApproveValue(to_, tokenId_)) {
            _allTokens[_allTokensIndex[tokenId_]].valueApprovals.push(to_);
        }
        _approvedValues[tokenId_][to_] = value_;

        emit ApprovalValue(tokenId_, to_, value_);
    }

    function _clearApprovedValues(uint256 tokenId_) internal virtual {
        TokenData storage tokenData = _allTokens[_allTokensIndex[tokenId_]];
        uint256 length = tokenData.valueApprovals.length;
        for (uint256 i = 0; i < length; i++) {
            address approval = tokenData.valueApprovals[i];
            delete _approvedValues[tokenId_][approval];
        }
        delete tokenData.valueApprovals;
    }

    function _existApproveValue(address to_, uint256 tokenId_) internal view virtual returns (bool) {
        uint256 length = _allTokens[_allTokensIndex[tokenId_]].valueApprovals.length;
        for (uint256 i = 0; i < length; i++) {
            if (_allTokens[_allTokensIndex[tokenId_]].valueApprovals[i] == to_) {
                return true;
            }
        }
        return false;
    }

    function _transferValue(
        uint256 fromTokenId_,
        uint256 toTokenId_,
        uint256 value_
    ) internal virtual {
        require(_exists(fromTokenId_), "ERC3525: transfer from invalid token ID");
        require(_exists(toTokenId_), "ERC3525: transfer to invalid token ID");

        TokenData storage fromTokenData = _allTokens[_allTokensIndex[fromTokenId_]];
        TokenData storage toTokenData = _allTokens[_allTokensIndex[toTokenId_]];

        require(fromTokenData.balance >= value_, "ERC3525: insufficient balance for transfer");
        require(fromTokenData.slot == toTokenData.slot, "ERC3525: transfer to token with different slot");

        _beforeValueTransfer(
            fromTokenData.owner,
            toTokenData.owner,
            fromTokenId_,
            toTokenId_,
            fromTokenData.slot,
            value_
        );

        fromTokenData.balance -= value_;
        toTokenData.balance += value_;

        emit TransferValue(fromTokenId_, toTokenId_, value_);

        _afterValueTransfer(
            fromTokenData.owner,
            toTokenData.owner,
            fromTokenId_,
            toTokenId_,
            fromTokenData.slot,
            value_
        );

        require(
            _checkOnERC3525Received(fromTokenId_, toTokenId_, value_, ""),
            "ERC3525: transfer rejected by ERC3525Receiver"
        );
    }

    function _transferTokenId(
        address from_,
        address to_,
        uint256 tokenId_
    ) internal virtual {
        require(ERC3525.ownerOf(tokenId_) == from_, "ERC3525: transfer from invalid owner");
        require(to_ != address(0), "ERC3525: transfer to the zero address");

        uint256 slot = ERC3525.slotOf(tokenId_);
        uint256 value = ERC3525.balanceOf(tokenId_);

        _beforeValueTransfer(from_, to_, tokenId_, tokenId_, slot, value);

        _approve(address(0), tokenId_);
        _clearApprovedValues(tokenId_);

        _removeTokenFromOwnerEnumeration(from_, tokenId_);
        _addTokenToOwnerEnumeration(to_, tokenId_);

        emit Transfer(from_, to_, tokenId_);

        _afterValueTransfer(from_, to_, tokenId_, tokenId_, slot, value);
    }

    function _safeTransferTokenId(
        address from_,
        address to_,
        uint256 tokenId_,
        bytes memory data_
    ) internal virtual {
        _transferTokenId(from_, to_, tokenId_);
        require(
            _checkOnERC721Received(from_, to_, tokenId_, data_),
            "ERC3525: transfer to non ERC721Receiver"
        );
    }

    function _checkOnERC3525Received( 
        uint256 fromTokenId_, 
        uint256 toTokenId_, 
        uint256 value_, 
        bytes memory data_
    ) private returns (bool) {
        address to = ERC3525.ownerOf(toTokenId_);
        if (to.isContract() && IERC165(to).supportsInterface(type(IERC3525Receiver).interfaceId)) {
            bytes4 retval = IERC3525Receiver(to).onERC3525Received(_msgSender(), fromTokenId_, toTokenId_, value_, data_);
            return retval == IERC3525Receiver.onERC3525Received.selector;
        } else {
            return true;
        }
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from_ address representing the previous owner of the given token ID
     * @param to_ target address that will receive the tokens
     * @param tokenId_ uint256 ID of the token to be transferred
     * @param data_ bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from_,
        address to_,
        uint256 tokenId_,
        bytes memory data_
    ) private returns (bool) {
        if (to_.isContract()) {
            try 
                IERC721Receiver(to_).onERC721Received(_msgSender(), from_, tokenId_, data_) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    /// @solidity memory-safe-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /* solhint-disable */
    function _beforeValueTransfer(
        address from_,
        address to_,
        uint256 fromTokenId_,
        uint256 toTokenId_,
        uint256 slot_,
        uint256 value_
    ) internal virtual {}

    function _afterValueTransfer(
        address from_,
        address to_,
        uint256 fromTokenId_,
        uint256 toTokenId_,
        uint256 slot_,
        uint256 value_
    ) internal virtual {}
    /* solhint-enable */

    function _setMetadataDescriptor(address metadataDescriptor_) internal virtual {
        metadataDescriptor = IERC3525MetadataDescriptor(metadataDescriptor_);
        emit SetMetadataDescriptor(metadataDescriptor_);
    }

    function _createOriginalTokenId() internal virtual returns (uint256) {
         _tokenIdGenerator.increment();
        return _tokenIdGenerator.current();
    }

    function _createDerivedTokenId(uint256 fromTokenId_) internal virtual returns (uint256) {
        fromTokenId_;
        return _createOriginalTokenId();
    }
}


// File @openzeppelin/contracts/access/[email protected]

// 
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}


// File @openzeppelin/contracts/security/[email protected]

// 
// OpenZeppelin Contracts (last updated v4.9.0) (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

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

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

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be _NOT_ENTERED
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

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

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

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == _ENTERED;
    }
}


// File contracts/HomelessCard.sol

// 
pragma solidity ^0.8.9;
contract HomelessCard is ERC3525, Ownable, ReentrancyGuard {
    address public homelessDog;
    uint256 public totalShare;
    uint256 public constant SLOT = 0;

    modifier onlyHomeless() {
        require(msg.sender == homelessDog, "Not granted");
        _;
    }

    constructor(address homelessDog_) ERC3525("HomelessCard", "HomelessCard", 18) {
        homelessDog = homelessDog_;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        ownerOf(tokenId);
        return "https://homelessdog.infura-ipfs.io/ipfs/Qmaq8XCfs9xPdnmG2mbvpWE7hMQ4NpSZd5GqZYnkUgiuVU";
    }

    function mint(address to, uint256 value) external payable onlyHomeless {
        totalShare += value;
        uint256 tokenId;
        if (balanceOf(to) > 0) {
            tokenId = tokenOfOwnerByIndex(to, 0);
            ERC3525._mintValue(tokenId, value);
        } else {
            tokenId = _createOriginalTokenId();
            ERC3525._mint(to, tokenId, SLOT, value);
        }
    }

    function burnValue(uint256 tokenId_, uint256 burnValue_) external nonReentrant {
        require(_isApprovedOrOwner(_msgSender(), tokenId_), "ERC3525: caller is not token owner nor approved");
        require(burnValue_ > 0, "burnValue is zero");
        ERC3525._burnValue(tokenId_, burnValue_);

        uint256 ethAmount = (address(this).balance * burnValue_) / totalShare;
        totalShare -= burnValue_;

        (bool success, ) = _msgSender().call{value: ethAmount}("");
        require(success, "Unable to send value");
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"homelessDog_","type":"address"}],"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":"uint256","name":"_tokenId","type":"uint256"},{"indexed":true,"internalType":"address","name":"_operator","type":"address"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"ApprovalValue","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":"metadataDescriptor","type":"address"}],"name":"SetMetadataDescriptor","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_tokenId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"_oldSlot","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"_newSlot","type":"uint256"}],"name":"SlotChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"_from","type":"address"},{"indexed":true,"internalType":"address","name":"_to","type":"address"},{"indexed":true,"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"_fromTokenId","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"_toTokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_value","type":"uint256"}],"name":"TransferValue","type":"event"},{"inputs":[],"name":"SLOT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"},{"internalType":"address","name":"operator_","type":"address"}],"name":"allowance","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":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"},{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint256","name":"value_","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"owner_","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"},{"internalType":"uint256","name":"burnValue_","type":"uint256"}],"name":"burnValue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"contractURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"homelessDog","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":"metadataDescriptor","outputs":[{"internalType":"contract IERC3525MetadataDescriptor","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"owner_","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from_","type":"address"},{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"payable","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":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"operator_","type":"address"},{"internalType":"bool","name":"approved_","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"slotOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"slot_","type":"uint256"}],"name":"slotURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index_","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner_","type":"address"},{"internalType":"uint256","name":"index_","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShare","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":"uint256","name":"fromTokenId_","type":"uint256"},{"internalType":"address","name":"to_","type":"address"},{"internalType":"uint256","name":"value_","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"uint256","name":"newTokenId","type":"uint256"}],"stateMutability":"payable","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":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"fromTokenId_","type":"uint256"},{"internalType":"uint256","name":"toTokenId_","type":"uint256"},{"internalType":"uint256","name":"value_","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"valueDecimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

79037:1601:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51311:484;;;;;;;;;;-1:-1:-1;51311:484:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;51311:484:0;;;;;;;;79136:25;;;;;;;;;;;;;;;;;;;738::1;;;726:2;711:18;79136:25:0;592:177:1;51869:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;57486:193::-;;;;;;;;;;-1:-1:-1;57486:193:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1879:32:1;;;1861:51;;1849:2;1834:18;57486:193:0;1715:203:1;57042:436:0;;;;;;:::i;:::-;;:::i;:::-;;53573:432;;;;;;;;;;-1:-1:-1;53573:432:0;;;;;:::i;:::-;;:::i;55196:424::-;;;;;;:::i;:::-;;:::i;58034:113::-;;;;;;;;;;-1:-1:-1;58122:10:0;:17;58034:113;;56161:307;;;;;;:::i;:::-;;:::i;52828:184::-;;;;;;;;;;-1:-1:-1;52828:184:0;;;;;:::i;:::-;;:::i;58384:266::-;;;;;;;;;;-1:-1:-1;58384:266:0;;;;;:::i;:::-;;:::i;55628:275::-;;;;;;:::i;:::-;;:::i;52245:105::-;;;;;;;;;;-1:-1:-1;52333:9:0;;52245:105;;52333:9;;;;3483:36:1;;3471:2;3456:18;52245:105:0;3341:184:1;79681:401:0;;;;;;:::i;:::-;;:::i;56835:199::-;;;;;;:::i;:::-;;:::i;58155:221::-;;;;;;;;;;-1:-1:-1;58155:221:0;;;;;:::i;:::-;;:::i;52556:264::-;;;;;;;;;;-1:-1:-1;52556:264:0;;;;;:::i;:::-;;:::i;55911:242::-;;;;;;;;;;-1:-1:-1;55911:242:0;;;;;:::i;:::-;;:::i;74899:103::-;;;;;;;;;;;;;:::i;79168:32::-;;;;;;;;;;;;79199:1;79168:32;;51076:52;;;;;;;;;;-1:-1:-1;51076:52:0;;;;-1:-1:-1;;;;;51076:52:0;;;80090:545;;;;;;;;;;-1:-1:-1;80090:545:0;;;;;:::i;:::-;;:::i;54588:392::-;;;;;;:::i;:::-;;:::i;74258:87::-;;;;;;;;;;-1:-1:-1;74331:6:0;;-1:-1:-1;;;;;74331:6:0;74258:87;;52045:104;;;;;;;;;;;;;:::i;52358:190::-;;;;;;;;;;-1:-1:-1;52358:190:0;;;;;:::i;:::-;;:::i;57687:159::-;;;;;;;;;;-1:-1:-1;57687:159:0;;;;;:::i;:::-;;:::i;79103:26::-;;;;;;;;;;-1:-1:-1;79103:26:0;;;;-1:-1:-1;;;;;79103:26:0;;;56476:351;;;;;;:::i;:::-;;:::i;79452:221::-;;;;;;;;;;-1:-1:-1;79452:221:0;;;;;:::i;:::-;;:::i;54988:200::-;;;;;;;;;;-1:-1:-1;54988:200:0;;;;;:::i;:::-;;:::i;53122:443::-;;;;;;;;;;;;;:::i;57854:172::-;;;;;;;;;;-1:-1:-1;57854:172:0;;;;;:::i;:::-;-1:-1:-1;;;;;57977:20:0;;;57953:4;57977:20;;;:12;:20;;;;;;;;:41;;;;;;:30;;;;:41;;;;;;;;57854:172;75157:201;;;;;;;;;;-1:-1:-1;75157:201:0;;;;;:::i;:::-;;:::i;51311:484::-;51396:4;-1:-1:-1;;;;;;51433:40:0;;-1:-1:-1;;;51433:40:0;;:98;;-1:-1:-1;;;;;;;51490:41:0;;-1:-1:-1;;;51490:41:0;51433:98;:155;;;-1:-1:-1;;;;;;;51548:40:0;;-1:-1:-1;;;51548:40:0;51433:155;:221;;;-1:-1:-1;;;;;;;51605:49:0;;-1:-1:-1;;;51605:49:0;51433:221;:288;;;-1:-1:-1;;;;;;;51671:50:0;;-1:-1:-1;;;51671:50:0;51433:288;:354;;;-1:-1:-1;;;;;;;51739:48:0;;-1:-1:-1;;;51739:48:0;51433:354;51413:374;51311:484;-1:-1:-1;;51311:484:0:o;51869:100::-;51923:13;51956:5;51949:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51869:100;:::o;57486:193::-;57563:7;57583:24;57598:8;57583:14;:24::i;:::-;57636:25;;;;:15;:25;;;;;;57625:10;:37;;:10;;57636:25;57625:37;;;;;;:::i;:::-;;;;;;;;;:46;:37;;;;;:46;;-1:-1:-1;;;;;57625:46:0;;57486:193;-1:-1:-1;;57486:193:0:o;57042:436::-;57133:13;57149:25;57165:8;57149:15;:25::i;:::-;57133:41;;57200:5;-1:-1:-1;;;;;57193:12:0;:3;-1:-1:-1;;;;;57193:12:0;;57185:59;;;;-1:-1:-1;;;57185:59:0;;;;;;;:::i;:::-;;;;;;;;;16314:10;-1:-1:-1;;;;;57279:21:0;;;;:70;;-1:-1:-1;57304:45:0;57329:5;16314:10;57854:172;:::i;57304:45::-;57257:177;;;;-1:-1:-1;;;57257:177:0;;7802:2:1;57257:177:0;;;7784:21:1;7841:2;7821:18;;;7814:30;7880:34;7860:18;;;7853:62;7951:27;7931:18;;;7924:55;7996:19;;57257:177:0;7600:421:1;57257:177:0;57447:23;57456:3;57461:8;57447;:23::i;:::-;57122:356;57042:436;;:::o;53573:432::-;53643:13;53669:21;53693:10;53097:9;;;;;;;;;-1:-1:-1;53097:9:0;;;53020:94;53693:10;53743:18;;53669:34;;-1:-1:-1;;;;;;53743:18:0;53735:262;;53884:1;53866:7;53860:21;:25;:137;;;;;;;;;;;;;;53735:262;;53860:137;53934:7;53952:16;:5;:14;:16::i;:::-;53917:52;;;;;;;;;:::i;:::-;;;;;;;;;;;;;53735:262;;;53797:18;;:42;;-1:-1:-1;;;53797:42:0;;;;;738:25:1;;;-1:-1:-1;;;;;53797:18:0;;;;:35;;711:18:1;;53797:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53797:42:0;;;;;;;;;;;;:::i;:::-;53714:283;53573:432;-1:-1:-1;;;53573:432:0:o;55196:424::-;55344:18;55375:51;16314:10;55405:12;55419:6;55375:15;:51::i;:::-;55452:35;55474:12;55452:21;:35::i;:::-;55439:48;;55498:55;55504:3;55509:10;55521:28;55536:12;55521:14;:28::i;:::-;55551:1;55498:5;:55::i;:::-;55564:48;55579:12;55593:10;55605:6;55564:14;:48::i;56161:307::-;56314:42;16314:10;56347:8;56314:18;:42::i;:::-;56306:105;;;;-1:-1:-1;;;56306:105:0;;;;;;;:::i;:::-;56422:38;56439:5;56446:3;56451:8;56422:16;:38::i;52828:184::-;52900:7;52920:24;52935:8;52920:14;:24::i;:::-;52973:25;;;;:15;:25;;;;;;52962:10;:37;;:10;;52973:25;52962:37;;;;;;:::i;:::-;;;;;;;;;;;:42;;;52955:49;;52828:184;;;:::o;58384:266::-;58483:7;58520:25;58538:6;58520:17;:25::i;:::-;58511:6;:34;58503:81;;;;-1:-1:-1;;;58503:81:0;;9949:2:1;58503:81:0;;;9931:21:1;9988:2;9968:18;;;9961:30;10027:34;10007:18;;;10000:62;-1:-1:-1;;;10078:18:1;;;10071:32;10120:19;;58503:81:0;9747:398:1;58503:81:0;-1:-1:-1;;;;;58602:20:0;;;;;;:12;:20;;;;;:40;;58635:6;;58602:40;;;;;;:::i;:::-;;;;;;;;;58595:47;;58384:266;;;;:::o;55628:275::-;55785:51;16314:10;55815:12;55829:6;55785:15;:51::i;:::-;55847:48;55862:12;55876:10;55888:6;55847:14;:48::i;79681:401::-;79266:11;;-1:-1:-1;;;;;79266:11:0;79252:10;:25;79244:49;;;;-1:-1:-1;;;79244:49:0;;10352:2:1;79244:49:0;;;10334:21:1;10391:2;10371:18;;;10364:30;-1:-1:-1;;;10410:18:1;;;10403:41;10461:18;;79244:49:0;10150:335:1;79244:49:0;79777:5:::1;79763:10;;:19;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;79793:15:0::1;::::0;-1:-1:-1;79793:15:0;79823:13:::1;79833:2:::0;79823:9:::1;:13::i;:::-;:17;79819:256;;;79867:26;79887:2;79891:1;79867:19;:26::i;:::-;79857:36;;79908:34;79927:7;79936:5;79908:18;:34::i;79819:256::-;79985:24;:22;:24::i;:::-;79975:34;;80024:39;80038:2;80042:7;79199:1;80057:5;80024:13;:39::i;56835:199::-:0;56984:42;57001:5;57008:3;57013:8;56984:42;;;;;;;;;;;;:16;:42::i;58155:221::-;58231:7;58268:21;58122:10;:17;;58034:113;58268:21;58259:6;:30;58251:78;;;;-1:-1:-1;;;58251:78:0;;10954:2:1;58251:78:0;;;10936:21:1;10993:2;10973:18;;;10966:30;11032:34;11012:18;;;11005:62;-1:-1:-1;;;11083:18:1;;;11076:33;11126:19;;58251:78:0;10752:399:1;58251:78:0;58347:10;58358:6;58347:18;;;;;;;;:::i;:::-;;;;;;;;;;;:21;;;58340:28;;58155:221;;;:::o;52556:264::-;52629:14;52656:24;52671:8;52656:14;:24::i;:::-;52711:25;;;;:15;:25;;;;;;52700:10;:37;;:10;;52711:25;52700:37;;;;;;:::i;:::-;;;;;;;;;:43;:37;;;;;:43;;-1:-1:-1;;;;;52700:43:0;;-1:-1:-1;52700:43:0;52754:58;;;;-1:-1:-1;;;52754:58:0;;11358:2:1;52754:58:0;;;11340:21:1;11397:2;11377:18;;;11370:30;-1:-1:-1;;;11416:18:1;;;11409:55;11481:18;;52754:58:0;11156:349:1;52754:58:0;52556:264;;;:::o;55911:242::-;55984:15;-1:-1:-1;;;;;56020:20:0;;56012:76;;;;-1:-1:-1;;;56012:76:0;;11712:2:1;56012:76:0;;;11694:21:1;11751:2;11731:18;;;11724:30;11790:34;11770:18;;;11763:62;-1:-1:-1;;;11841:18:1;;;11834:41;11892:19;;56012:76:0;11510:407:1;56012:76:0;-1:-1:-1;;;;;;56106:20:0;;;;;:12;:20;;;;;:39;;55911:242::o;74899:103::-;74144:13;:11;:13::i;:::-;74964:30:::1;74991:1;74964:18;:30::i;:::-;74899:103::o:0;80090:545::-;78072:21;:19;:21::i;:::-;80188:42:::1;16314:10:::0;80207:12:::1;80221:8;80188:18;:42::i;:::-;80180:102;;;::::0;-1:-1:-1;;;80180:102:0;;12124:2:1;80180:102:0::1;::::0;::::1;12106:21:1::0;12163:2;12143:18;;;12136:30;12202:34;12182:18;;;12175:62;-1:-1:-1;;;12253:18:1;;;12246:45;12308:19;;80180:102:0::1;11922:411:1::0;80180:102:0::1;80314:1;80301:10;:14;80293:44;;;::::0;-1:-1:-1;;;80293:44:0;;12540:2:1;80293:44:0::1;::::0;::::1;12522:21:1::0;12579:2;12559:18;;;12552:30;-1:-1:-1;;;12598:18:1;;;12591:47;12655:18;;80293:44:0::1;12338:341:1::0;80293:44:0::1;80348:40;80367:8;80377:10;80348:18;:40::i;:::-;80460:10;::::0;80401:17:::1;::::0;80422:34:::1;80446:10:::0;80422:21:::1;:34;:::i;:::-;80421:49;;;;:::i;:::-;80401:69;;80495:10;80481;;:24;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;80537:39:0::1;::::0;80519:12:::1;::::0;16314:10;;80562:9;;80519:12;80537:39;80519:12;80537:39;80562:9;16314:10;80537:39:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80518:58;;;80595:7;80587:40;;;::::0;-1:-1:-1;;;80587:40:0;;13756:2:1;80587:40:0::1;::::0;::::1;13738:21:1::0;13795:2;13775:18;;;13768:30;-1:-1:-1;;;13814:18:1;;;13807:50;13874:18;;80587:40:0::1;13554:344:1::0;80587:40:0::1;80169:466;;78116:20:::0;77510:1;78636:7;:22;78453:213;78116:20;80090:545;;:::o;54588:392::-;54695:13;54711:25;54727:8;54711:15;:25::i;:::-;54695:41;;54762:5;-1:-1:-1;;;;;54755:12:0;:3;-1:-1:-1;;;;;54755:12:0;;54747:59;;;;-1:-1:-1;;;54747:59:0;;;;;;;:::i;:::-;54827:42;16314:10;54860:8;54827:18;:42::i;:::-;54819:104;;;;-1:-1:-1;;;54819:104:0;;14105:2:1;54819:104:0;;;14087:21:1;14144:2;14124:18;;;14117:30;14183:34;14163:18;;;14156:62;-1:-1:-1;;;14234:18:1;;;14227:47;14291:19;;54819:104:0;13903:413:1;54819:104:0;54936:36;54950:8;54960:3;54965:6;54936:13;:36::i;:::-;54684:296;54588:392;;;:::o;52045:104::-;52101:13;52134:7;52127:14;;;;;:::i;52358:190::-;52433:7;52453:24;52468:8;52453:14;:24::i;:::-;52506:25;;;;:15;:25;;;;;;52495:10;:37;;:10;;52506:25;52495:37;;;;;;:::i;:::-;;;;;;;;;;;:45;;;52488:52;;52358:190;;;:::o;57687:159::-;57784:54;16314:10;57817:9;57828;57784:18;:54::i;56476:351::-;56662:42;16314:10;56681:12;16234:98;56662:42;56654:105;;;;-1:-1:-1;;;56654:105:0;;;;;;;:::i;:::-;56770:49;56791:5;56798:3;56803:8;56813:5;56770:20;:49::i;79452:221::-;79517:13;79543:16;79551:7;79543;:16::i;:::-;;79570:95;;;;;;;;;;;;;;;;;;79452:221;-1:-1:-1;;79452:221:0:o;54988:200::-;55082:7;55102:24;55117:8;55102:14;:24::i;:::-;-1:-1:-1;55144:25:0;;;;:15;:25;;;;;;;;-1:-1:-1;;;;;55144:36:0;;;;;;;;;;;;;54988:200::o;53122:443::-;53183:13;53209:21;53233:10;53097:9;;;;;;;;;-1:-1:-1;53097:9:0;;;53020:94;53233:10;53283:18;;53209:34;;-1:-1:-1;;;;;;53283:18:0;53275:282;;53422:1;53404:7;53398:21;:25;:159;;;;;;;;;;;;;;53275:282;;53398:159;53472:7;53494:34;53522:4;53494:19;:34::i;:::-;53455:74;;;;;;;;;:::i;:::-;;;;;;;;;;;;;53275:282;;;53337:18;;;;;;;;;-1:-1:-1;;;;;53337:18:0;-1:-1:-1;;;;;53337:39:0;;:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53337:41:0;;;;;;;;;;;;:::i;:::-;53254:303;;;53122:443;:::o;75157:201::-;74144:13;:11;:13::i;:::-;-1:-1:-1;;;;;75246:22:0;::::1;75238:73;;;::::0;-1:-1:-1;;;75238:73:0;;15176:2:1;75238:73:0::1;::::0;::::1;15158:21:1::0;15215:2;15195:18;;;15188:30;15254:34;15234:18;;;15227:62;-1:-1:-1;;;15305:18:1;;;15298:36;15351:19;;75238:73:0::1;14974:402:1::0;75238:73:0::1;75322:28;75341:8;75322:18;:28::i;:::-;75157:201:::0;:::o;59992:138::-;60075:17;60083:8;60075:7;:17::i;:::-;60067:55;;;;-1:-1:-1;;;60067:55:0;;11358:2:1;60067:55:0;;;11340:21:1;11397:2;11377:18;;;11370:30;-1:-1:-1;;;11416:18:1;;;11409:55;11481:18;;60067:55:0;11156:349:1;65753:203:0;65841:25;;;;:15;:25;;;;;;65830:10;:37;;65879:3;;65841:25;65830:37;;;;;;:::i;:::-;;;;;;;;;;;;;;:46;;:52;;-1:-1:-1;;;;;;65830:52:0;-1:-1:-1;;;;;65830:52:0;;;;;;65939:8;;65898:50;;65907:25;65939:8;65907:15;:25::i;:::-;-1:-1:-1;;;;;65898:50:0;;;;;;;;;;;65753:203;;:::o;31399:716::-;31455:13;31506:14;31523:17;31534:5;31523:10;:17::i;:::-;31543:1;31523:21;31506:38;;31559:20;31593:6;31582:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31582:18:0;-1:-1:-1;31559:41:0;-1:-1:-1;31724:28:0;;;31740:2;31724:28;31781:288;-1:-1:-1;;31813:5:0;-1:-1:-1;;;31950:2:0;31939:14;;31934:30;31813:5;31921:44;32011:2;32002:11;;;-1:-1:-1;32032:21:0;31781:288;32032:21;-1:-1:-1;32090:6:0;31399:716;-1:-1:-1;;;31399:716:0:o;59351:449::-;59457:24;59484:38;59502:8;59512:9;59484:17;:38::i;:::-;59457:65;;59538:39;59557:9;59568:8;59538:18;:39::i;:::-;59537:40;:81;;;;;-1:-1:-1;;59581:16:0;:37;;59537:81;59533:260;;;59663:6;59643:16;:26;;59635:70;;;;-1:-1:-1;;;59635:70:0;;15583:2:1;59635:70:0;;;15565:21:1;15622:2;15602:18;;;15595:30;15661:33;15641:18;;;15634:61;15712:18;;59635:70:0;15381:355:1;59635:70:0;59720:61;59734:8;59744:9;59755:25;59774:6;59755:16;:25;:::i;:::-;59720:13;:61::i;72846:161::-;72925:7;72975:24;:22;:24::i;60348:554::-;-1:-1:-1;;;;;60461:17:0;;60453:63;;;;-1:-1:-1;;;60453:63:0;;15943:2:1;60453:63:0;;;15925:21:1;15982:2;15962:18;;;15955:30;16021:34;16001:18;;;15994:62;-1:-1:-1;;;16072:18:1;;;16065:31;16113:19;;60453:63:0;15741:397:1;60453:63:0;60535:8;60547:1;60535:13;60527:59;;;;-1:-1:-1;;;60527:59:0;;16345:2:1;60527:59:0;;;16327:21:1;16384:2;16364:18;;;16357:30;16423:34;16403:18;;;16396:62;-1:-1:-1;;;16474:18:1;;;16467:31;16515:19;;60527:59:0;16143:397:1;60527:59:0;60606:17;60614:8;60606:7;:17::i;:::-;60605:18;60597:60;;;;-1:-1:-1;;;60597:60:0;;16747:2:1;60597:60:0;;;16729:21:1;16786:2;16766:18;;;16759:30;16825:31;16805:18;;;16798:59;16874:18;;60597:60:0;16545:353:1;60597:60:0;60746:33;60758:3;60763:8;60773:5;60746:11;:33::i;:::-;60790:29;60802:8;60812:6;60790:11;:29::i;:::-;60830:64;62805:683;67273:1431;67425:21;67433:12;67425:7;:21::i;:::-;67417:73;;;;-1:-1:-1;;;67417:73:0;;17105:2:1;67417:73:0;;;17087:21:1;17144:2;17124:18;;;17117:30;17183:34;17163:18;;;17156:62;-1:-1:-1;;;17234:18:1;;;17227:37;17281:19;;67417:73:0;16903:403:1;67417:73:0;67509:19;67517:10;67509:7;:19::i;:::-;67501:69;;;;-1:-1:-1;;;67501:69:0;;17513:2:1;67501:69:0;;;17495:21:1;17552:2;17532:18;;;17525:30;17591:34;17571:18;;;17564:62;-1:-1:-1;;;17642:18:1;;;17635:35;17687:19;;67501:69:0;17311:401:1;67501:69:0;67583:31;67628:29;;;:15;:29;;;;;;67617:10;:41;;:10;;67628:29;67617:41;;;;;;:::i;:::-;;;;;;;;;;;67583:75;;67669:29;67701:10;67712:15;:27;67728:10;67712:27;;;;;;;;;;;;67701:39;;;;;;;;:::i;:::-;;;;;;;;;;;67669:71;;67786:6;67761:13;:21;;;:31;;67753:86;;;;-1:-1:-1;;;67753:86:0;;17919:2:1;67753:86:0;;;17901:21:1;17958:2;17938:18;;;17931:30;17997:34;17977:18;;;17970:62;-1:-1:-1;;;18048:18:1;;;18041:40;18098:19;;67753:86:0;17717:406:1;67753:86:0;67880:11;:16;;;67858:13;:18;;;:38;67850:97;;;;-1:-1:-1;;;67850:97:0;;18330:2:1;67850:97:0;;;18312:21:1;18369:2;18349:18;;;18342:30;18408:34;18388:18;;;18381:62;-1:-1:-1;;;18459:18:1;;;18452:44;18513:19;;67850:97:0;18128:410:1;67850:97:0;68201:6;68176:13;:21;;;:31;;;;;;;:::i;:::-;;;;;;;;68241:6;68218:11;:19;;;:29;;;;;;;:::i;:::-;;;;-1:-1:-1;;68265:47:0;;738:25:1;;;68293:10:0;;68279:12;;68265:47;;726:2:1;711:18;68265:47:0;;;;;;;68562:61;68586:12;68600:10;68612:6;68562:61;;;;;;;;;;;;:23;:61::i;:::-;68540:156;;;;-1:-1:-1;;;68540:156:0;;18745:2:1;68540:156:0;;;18727:21:1;18784:2;18764:18;;;18757:30;18823:34;18803:18;;;18796:62;-1:-1:-1;;;18874:18:1;;;18867:43;18927:19;;68540:156:0;18543:409:1;68540:156:0;67406:1298;;67273:1431;;;:::o;59001:342::-;59097:4;59114:13;59130:25;59146:8;59130:15;:25::i;:::-;59114:41;;59201:5;-1:-1:-1;;;;;59188:18:0;:9;-1:-1:-1;;;;;59188:18:0;;:77;;;-1:-1:-1;;;;;;57977:20:0;;;57953:4;57977:20;;;:12;:20;;;;;;;;:41;;;;;:30;;;;:41;;;;;;59223:42;59188:136;;;;59315:9;-1:-1:-1;;;;;59282:42:0;:29;59302:8;59282:19;:29::i;:::-;-1:-1:-1;;;;;59282:42:0;;59188:136;59166:169;59001:342;-1:-1:-1;;;;59001:342:0:o;68712:811::-;68883:5;-1:-1:-1;;;;;68854:34:0;:25;68870:8;68854:15;:25::i;:::-;-1:-1:-1;;;;;68854:34:0;;68846:83;;;;-1:-1:-1;;;68846:83:0;;19159:2:1;68846:83:0;;;19141:21:1;19198:2;19178:18;;;19171:30;19237:34;19217:18;;;19210:62;-1:-1:-1;;;19288:18:1;;;19281:34;19332:19;;68846:83:0;18957:400:1;68846:83:0;-1:-1:-1;;;;;68948:17:0;;68940:67;;;;-1:-1:-1;;;68940:67:0;;19564:2:1;68940:67:0;;;19546:21:1;19603:2;19583:18;;;19576:30;19642:34;19622:18;;;19615:62;-1:-1:-1;;;19693:18:1;;;19686:35;19738:19;;68940:67:0;19362:401:1;68940:67:0;69020:12;69035:24;69050:8;69035:14;:24::i;:::-;69020:39;;69070:13;69086:27;69104:8;69086:17;:27::i;:::-;69070:43;;69204:30;69221:1;69225:8;69204;:30::i;:::-;69245;69266:8;69245:20;:30::i;:::-;69288:49;69321:5;69328:8;69288:32;:49::i;:::-;69348:42;69376:3;69381:8;69348:27;:42::i;:::-;69429:8;69424:3;-1:-1:-1;;;;;69408:30:0;69417:5;-1:-1:-1;;;;;69408:30:0;;;;;;;;;;;69451:64;62805:683;60910:374;60992:13;61008:25;61024:8;61008:15;:25::i;:::-;60992:41;;61044:12;61059:24;61074:8;61059:14;:24::i;:::-;61044:39;;61171:29;61183:8;61193:6;61171:11;:29::i;72675:163::-;72735:7;72756:29;:17;34895:19;;34913:1;34895:19;;;34806:127;72756:29;-1:-1:-1;72803:17:0;34776:14;;72675:163::o;74423:132::-;74331:6;;-1:-1:-1;;;;;74331:6:0;16314:10;74487:23;74479:68;;;;-1:-1:-1;;;74479:68:0;;19970:2:1;74479:68:0;;;19952:21:1;;;19989:18;;;19982:30;20048:34;20028:18;;;20021:62;20100:18;;74479:68:0;19768:356:1;75518:191:0;75611:6;;;-1:-1:-1;;;;;75628:17:0;;;-1:-1:-1;;;;;;75628:17:0;;;;;;;75661:40;;75611:6;;;75628:17;75611:6;;75661:40;;75592:16;;75661:40;75581:128;75518:191;:::o;78152:293::-;77554:1;78286:7;;:19;78278:63;;;;-1:-1:-1;;;78278:63:0;;20331:2:1;78278:63:0;;;20313:21:1;20370:2;20350:18;;;20343:30;20409:33;20389:18;;;20382:61;20460:18;;78278:63:0;20129:355:1;78278:63:0;77554:1;78419:7;:18;78152:293::o;62805:683::-;62891:24;62906:8;62891:14;:24::i;:::-;62928:27;62969:25;;;:15;:25;;;;;;62958:10;:37;;:10;;62969:25;62958:37;;;;;;:::i;:::-;;;;;;;;;;;;;;63022:15;;;;;63063:14;;;63104:17;;;;62958:37;;-1:-1:-1;;;;;;63022:15:0;;;;63142:19;;;;63134:67;;;;-1:-1:-1;;;63134:67:0;;20691:2:1;63134:67:0;;;20673:21:1;20730:2;20710:18;;;20703:30;20769:34;20749:18;;;20742:62;-1:-1:-1;;;20820:18:1;;;20813:33;20863:19;;63134:67:0;20489:399:1;63134:67:0;63326:10;63305:9;:17;;;:31;;;;;;;:::i;:::-;;;;-1:-1:-1;;63352:38:0;;738:25:1;;;63376:1:0;;63366:8;;63352:38;;726:2:1;711:18;63352:38:0;;;;;;;62880:608;;;;62805:683;;:::o;65964:455::-;-1:-1:-1;;;;;66104:17:0;;66096:72;;;;-1:-1:-1;;;66096:72:0;;21095:2:1;66096:72:0;;;21077:21:1;21134:2;21114:18;;;21107:30;21173:34;21153:18;;;21146:62;-1:-1:-1;;;21224:18:1;;;21217:40;21274:19;;66096:72:0;20893:406:1;66096:72:0;66184:33;66203:3;66208:8;66184:18;:33::i;:::-;66179:129;;66245:25;;;;:15;:25;;;;;;66234:10;:37;;:10;;66245:25;66234:37;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:52;;:62;;;;;;;;;;;;;;;-1:-1:-1;;;;;;66234:62:0;-1:-1:-1;;;;;66234:62:0;;;;;66179:129;66318:25;;;;:15;:25;;;;;;;;-1:-1:-1;;;;;66318:30:0;;;;;;;;;;;;:39;;;66375:36;738:25:1;;;66318::0;;66375:36;;711:18:1;66375:36:0;;;;;;;;65964:455;;;:::o;58658:335::-;58817:9;-1:-1:-1;;;;;58807:19:0;:6;-1:-1:-1;;;;;58807:19:0;;58799:58;;;;-1:-1:-1;;;58799:58:0;;21506:2:1;58799:58:0;;;21488:21:1;21545:2;21525:18;;;21518:30;21584:28;21564:18;;;21557:56;21630:18;;58799:58:0;21304:350:1;58799:58:0;-1:-1:-1;;;;;58870:20:0;;;;;;;:12;:20;;;;;;;;:41;;;;;;:30;;;;:41;;;;;;:53;;-1:-1:-1;;58870:53:0;;;;;;;;;;58941:44;;540:41:1;;;58941:44:0;;513:18:1;58941:44:0;400:187:1;69531:364:0;69698:38;69715:5;69722:3;69727:8;69698:16;:38::i;:::-;69769:51;69792:5;69799:3;69804:8;69814:5;69769:22;:51::i;:::-;69747:140;;;;-1:-1:-1;;;69747:140:0;;21861:2:1;69747:140:0;;;21843:21:1;21900:2;21880:18;;;21873:30;21939:34;21919:18;;;21912:62;-1:-1:-1;;;21990:18:1;;;21983:37;22037:19;;69747:140:0;21659:403:1;33415:151:0;33473:13;33506:52;-1:-1:-1;;;;;33518:22:0;;31290:2;33506:11;:52::i;59808:176::-;59898:10;:17;59874:4;;59898:22;;;;:78;;-1:-1:-1;59935:25:0;;;;:15;:25;;;;;;59924:10;:37;;59968:8;;59935:25;59924:37;;;;;;:::i;:::-;;;;;;;;;;;:40;;;:52;59891:85;59808:176;-1:-1:-1;;59808:176:0:o;28224:948::-;28277:7;;-1:-1:-1;;;28355:17:0;;28351:106;;-1:-1:-1;;;28393:17:0;;;-1:-1:-1;28439:2:0;28429:12;28351:106;28484:8;28475:5;:17;28471:106;;28522:8;28513:17;;;-1:-1:-1;28559:2:0;28549:12;28471:106;28604:8;28595:5;:17;28591:106;;28642:8;28633:17;;;-1:-1:-1;28679:2:0;28669:12;28591:106;28724:7;28715:5;:16;28711:103;;28761:7;28752:16;;;-1:-1:-1;28797:1:0;28787:11;28711:103;28841:7;28832:5;:16;28828:103;;28878:7;28869:16;;;-1:-1:-1;28914:1:0;28904:11;28828:103;28958:7;28949:5;:16;28945:103;;28995:7;28986:16;;;-1:-1:-1;29031:1:0;29021:11;28945:103;29075:7;29066:5;:16;29062:68;;29113:1;29103:11;29158:6;28224:948;-1:-1:-1;;28224:948:0:o;61487:538::-;61602:207;;;;;;;;;;;;;;;;;;-1:-1:-1;61602:207:0;;;;;;-1:-1:-1;;;;;61602:207:0;;;;;;;;;;;;61781:16;;;;;;;;;;;61602:207;;;;61573:236;-1:-1:-1;61822:42:0;61573:236;61822:31;:42::i;:::-;61875;61903:3;61908:8;61875:27;:42::i;:::-;61935:35;;61961:8;;-1:-1:-1;;;;;61935:35:0;;;61952:1;;61935:35;;61952:1;;61935:35;62011:5;62008:1;61998:8;61986:31;;;;;;;;;;61562:463;61487:538;;;:::o;61292:187::-;61377:25;;;;:15;:25;;;;;;61366:10;:37;;61415:6;;61377:25;61366:37;;;;;;:::i;:::-;;;;;;;;;;;:45;;;:55;;;;;;;:::i;:::-;;;;-1:-1:-1;;61437:34:0;;738:25:1;;;61454:8:0;;61451:1;;61437:34;;726:2:1;711:18;61437:34:0;;;;;;;61292:187;;:::o;69903:595::-;70078:4;70095:10;70108:27;70124:10;70108:15;:27::i;:::-;70095:40;-1:-1:-1;;;;;;70150:13:0;;39641:19;:23;;70150:84;;;;-1:-1:-1;70169:65:0;;-1:-1:-1;;;70169:65:0;;-1:-1:-1;;;70169:65:0;;;22211:52:1;-1:-1:-1;;;;;70169:29:0;;;;;22184:18:1;;70169:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;70146:345;;;70267:93;;-1:-1:-1;;;70267:93:0;;70251:13;;-1:-1:-1;;;;;70267:38:0;;;;;:93;;16314:10;;70320:12;;70334:10;;70346:6;;70354:5;;70267:93;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;;70382:53:0;-1:-1:-1;;;70382:53:0;;-1:-1:-1;70375:60:0;;-1:-1:-1;;70375:60:0;70146:345;-1:-1:-1;70475:4:0;;69903:595;-1:-1:-1;;;;;69903:595:0:o;66427:429::-;66503:27;66544:25;;;:15;:25;;;;;;66533:10;:37;;:10;;66544:25;66533:37;;;;;;:::i;:::-;;;;;;;;66598:24;66533:37;;;;;66598:24;;;:31;66533:37;;-1:-1:-1;66598:31:0;66640:167;66664:6;66660:1;:10;66640:167;;;66692:16;66711:9;:24;;66736:1;66711:27;;;;;;;;:::i;:::-;;;;;;;;;;;;;66760:25;;;:15;:25;;;;;;-1:-1:-1;;;;;66711:27:0;;;66760:35;;;;;;66753:42;-1:-1:-1;66672:3:0;;;;:::i;:::-;;;;66640:167;;;-1:-1:-1;66817:31:0;66824:24;;;;66817:31;:::i;63799:645::-;63947:1;63904:25;;;:15;:25;;;;;;63893:10;:37;;:10;;63904:25;63893:37;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:43;;:56;;-1:-1:-1;;;;;;63893:56:0;-1:-1:-1;;;;;63893:56:0;;;;;;63994:19;;;;;:12;:19;;;;;;64049:28;;63994:19;;63893:37;64049:32;;-1:-1:-1;;64049:32:0;:::i;:::-;64024:57;;64092:19;64114:9;:21;;64136:14;64114:37;;;;;;;;:::i;:::-;;;;;;;;;64092:59;;64162:18;64183:9;:26;;:36;64210:8;64183:36;;;;;;;;;;;;64162:57;;64268:11;64232:9;:21;;64254:10;64232:33;;;;;;;;:::i;:::-;;;;;;;;;;;;:47;;;;64290:39;;;:26;;;:39;;;;;;;:52;;;64362:36;;;;;64355:43;64409:27;;64290:9;;64409:27;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;63882:562;;;;63799:645;;:::o;63496:295::-;63594:25;;;;:15;:25;;;;;;63583:10;:37;;63629:3;;63594:25;63583:37;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;:43;;:49;;-1:-1:-1;;;;;;63583:49:0;-1:-1:-1;;;;;63583:49:0;;;;;;63692:17;;;;;;:12;:17;;;;;;;:36;;63645:44;;;-1:-1:-1;63645:34:0;;;:44;;;;;:83;;;63739:17;;;:44;;;;;;;;;;;;;;63496:295::o;66864:401::-;66954:4;66999:25;;;:15;:25;;;;;;66988:10;:37;;66954:4;;66999:25;66988:37;;;;;;:::i;:::-;;;;;;;;:52;:37;;;;;:52;:59;;-1:-1:-1;67058:177:0;67082:6;67078:1;:10;67058:177;;;67125:25;;;;:15;:25;;;;;;67114:10;:37;;-1:-1:-1;;;;;67114:62:0;;;67125:25;67114:37;;;;;;:::i;:::-;;;;;;;;;;;:52;;67167:1;67114:55;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;67114:55:0;:62;67110:114;;67204:4;67197:11;;;;;;67110:114;67090:3;;;;:::i;:::-;;;;67058:177;;;-1:-1:-1;67252:5:0;;66864:401;-1:-1:-1;;;;66864:401:0:o;71066:880::-;71224:4;-1:-1:-1;;;;;71245:14:0;;39641:19;:23;71241:698;;71300:75;;-1:-1:-1;;;71300:75:0;;-1:-1:-1;;;;;71300:37:0;;;;;:75;;16314:10;;71352:5;;71359:8;;71369:5;;71300:75;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;71300:75:0;;;;;;;;-1:-1:-1;;71300:75:0;;;;;;;;;;;;:::i;:::-;;;71278:606;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71545:6;:13;71562:1;71545:18;71541:328;;71588:60;;-1:-1:-1;;;71588:60:0;;24282:2:1;71588:60:0;;;24264:21:1;24321:2;24301:18;;;24294:30;24360:34;24340:18;;;24333:62;-1:-1:-1;;;24411:18:1;;;24404:48;24469:19;;71588:60:0;24080:414:1;71541:328:0;71819:6;71813:13;71804:6;71800:2;71796:15;71789:38;71278:606;-1:-1:-1;;;;;;71426:51:0;-1:-1:-1;;;71426:51:0;;-1:-1:-1;71419:58:0;;71241:698;-1:-1:-1;71923:4:0;71916:11;;32811:447;32886:13;32912:19;32944:10;32948:6;32944:1;:10;:::i;:::-;:14;;32957:1;32944:14;:::i;:::-;32934:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32934:25:0;;32912:47;;-1:-1:-1;;;32970:6:0;32977:1;32970:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;32970:15:0;;;;;;;;;-1:-1:-1;;;32996:6:0;33003:1;32996:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;32996:15:0;;;;;;;;-1:-1:-1;33027:9:0;33039:10;33043:6;33039:1;:10;:::i;:::-;:14;;33052:1;33039:14;:::i;:::-;33027:26;;33022:131;33059:1;33055;:5;33022:131;;;-1:-1:-1;;;33103:5:0;33111:3;33103:11;33094:21;;;;;;;:::i;:::-;;;;33082:6;33089:1;33082:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;33082:33:0;;;;;;;;-1:-1:-1;33140:1:0;33130:11;;;;;33062:3;;;:::i;:::-;;;33022:131;;;-1:-1:-1;33171:10:0;;33163:55;;;;-1:-1:-1;;;33163:55:0;;24842:2:1;33163:55:0;;;24824:21:1;;;24861:18;;;24854:30;24920:34;24900:18;;;24893:62;24972:18;;33163:55:0;24640:356:1;64452:185:0;64574:10;:17;;64557:13;;64541:30;;;;:15;:30;;;;;;;;:50;;;64602:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;64602:27:0;;;-1:-1:-1;;;;;;64602:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64557:10;;64602:27;;;;;;;;;;:::i;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;774:250::-;859:1;869:113;883:6;880:1;877:13;869:113;;;959:11;;;953:18;940:11;;;933:39;905:2;898:10;869:113;;;-1:-1:-1;;1016:1:1;998:16;;991:27;774:250::o;1029:271::-;1071:3;1109:5;1103:12;1136:6;1131:3;1124:19;1152:76;1221:6;1214:4;1209:3;1205:14;1198:4;1191:5;1187:16;1152:76;:::i;:::-;1282:2;1261:15;-1:-1:-1;;1257:29:1;1248:39;;;;1289:4;1244:50;;1029:271;-1:-1:-1;;1029:271:1:o;1305:220::-;1454:2;1443:9;1436:21;1417:4;1474:45;1515:2;1504:9;1500:18;1492:6;1474:45;:::i;1530:180::-;1589:6;1642:2;1630:9;1621:7;1617:23;1613:32;1610:52;;;1658:1;1655;1648:12;1610:52;-1:-1:-1;1681:23:1;;1530:180;-1:-1:-1;1530:180:1:o;1923:173::-;1991:20;;-1:-1:-1;;;;;2040:31:1;;2030:42;;2020:70;;2086:1;2083;2076:12;2101:254;2169:6;2177;2230:2;2218:9;2209:7;2205:23;2201:32;2198:52;;;2246:1;2243;2236:12;2198:52;2269:29;2288:9;2269:29;:::i;:::-;2259:39;2345:2;2330:18;;;;2317:32;;-1:-1:-1;;;2101:254:1:o;2360:322::-;2437:6;2445;2453;2506:2;2494:9;2485:7;2481:23;2477:32;2474:52;;;2522:1;2519;2512:12;2474:52;2558:9;2545:23;2535:33;;2587:38;2621:2;2610:9;2606:18;2587:38;:::i;:::-;2577:48;;2672:2;2661:9;2657:18;2644:32;2634:42;;2360:322;;;;;:::o;2687:328::-;2764:6;2772;2780;2833:2;2821:9;2812:7;2808:23;2804:32;2801:52;;;2849:1;2846;2839:12;2801:52;2872:29;2891:9;2872:29;:::i;:::-;2862:39;;2920:38;2954:2;2943:9;2939:18;2920:38;:::i;3020:316::-;3097:6;3105;3113;3166:2;3154:9;3145:7;3141:23;3137:32;3134:52;;;3182:1;3179;3172:12;3134:52;-1:-1:-1;;3205:23:1;;;3275:2;3260:18;;3247:32;;-1:-1:-1;3326:2:1;3311:18;;;3298:32;;3020:316;-1:-1:-1;3020:316:1:o;3530:186::-;3589:6;3642:2;3630:9;3621:7;3617:23;3613:32;3610:52;;;3658:1;3655;3648:12;3610:52;3681:29;3700:9;3681:29;:::i;3964:248::-;4032:6;4040;4093:2;4081:9;4072:7;4068:23;4064:32;4061:52;;;4109:1;4106;4099:12;4061:52;-1:-1:-1;;4132:23:1;;;4202:2;4187:18;;;4174:32;;-1:-1:-1;3964:248:1:o;4217:118::-;4303:5;4296:13;4289:21;4282:5;4279:32;4269:60;;4325:1;4322;4315:12;4340:315;4405:6;4413;4466:2;4454:9;4445:7;4441:23;4437:32;4434:52;;;4482:1;4479;4472:12;4434:52;4505:29;4524:9;4505:29;:::i;:::-;4495:39;;4584:2;4573:9;4569:18;4556:32;4597:28;4619:5;4597:28;:::i;:::-;4644:5;4634:15;;;4340:315;;;;;:::o;4660:127::-;4721:10;4716:3;4712:20;4709:1;4702:31;4752:4;4749:1;4742:15;4776:4;4773:1;4766:15;4792:275;4863:2;4857:9;4928:2;4909:13;;-1:-1:-1;;4905:27:1;4893:40;;4963:18;4948:34;;4984:22;;;4945:62;4942:88;;;5010:18;;:::i;:::-;5046:2;5039:22;4792:275;;-1:-1:-1;4792:275:1:o;5072:186::-;5120:4;5153:18;5145:6;5142:30;5139:56;;;5175:18;;:::i;:::-;-1:-1:-1;5241:2:1;5220:15;-1:-1:-1;;5216:29:1;5247:4;5212:40;;5072:186::o;5263:888::-;5358:6;5366;5374;5382;5435:3;5423:9;5414:7;5410:23;5406:33;5403:53;;;5452:1;5449;5442:12;5403:53;5475:29;5494:9;5475:29;:::i;:::-;5465:39;;5523:38;5557:2;5546:9;5542:18;5523:38;:::i;:::-;5513:48;;5608:2;5597:9;5593:18;5580:32;5570:42;;5663:2;5652:9;5648:18;5635:32;5690:18;5682:6;5679:30;5676:50;;;5722:1;5719;5712:12;5676:50;5745:22;;5798:4;5790:13;;5786:27;-1:-1:-1;5776:55:1;;5827:1;5824;5817:12;5776:55;5863:2;5850:16;5888:48;5904:31;5932:2;5904:31;:::i;:::-;5888:48;:::i;:::-;5959:2;5952:5;5945:17;5999:7;5994:2;5989;5985;5981:11;5977:20;5974:33;5971:53;;;6020:1;6017;6010:12;5971:53;6075:2;6070;6066;6062:11;6057:2;6050:5;6046:14;6033:45;6119:1;6114:2;6109;6102:5;6098:14;6094:23;6087:34;6140:5;6130:15;;;;;5263:888;;;;;;;:::o;6156:254::-;6224:6;6232;6285:2;6273:9;6264:7;6260:23;6256:32;6253:52;;;6301:1;6298;6291:12;6253:52;6337:9;6324:23;6314:33;;6366:38;6400:2;6389:9;6385:18;6366:38;:::i;:::-;6356:48;;6156:254;;;;;:::o;6415:260::-;6483:6;6491;6544:2;6532:9;6523:7;6519:23;6515:32;6512:52;;;6560:1;6557;6550:12;6512:52;6583:29;6602:9;6583:29;:::i;:::-;6573:39;;6631:38;6665:2;6654:9;6650:18;6631:38;:::i;6680:380::-;6759:1;6755:12;;;;6802;;;6823:61;;6877:4;6869:6;6865:17;6855:27;;6823:61;6930:2;6922:6;6919:14;6899:18;6896:38;6893:161;;6976:10;6971:3;6967:20;6964:1;6957:31;7011:4;7008:1;7001:15;7039:4;7036:1;7029:15;6893:161;;6680:380;;;:::o;7065:127::-;7126:10;7121:3;7117:20;7114:1;7107:31;7157:4;7154:1;7147:15;7181:4;7178:1;7171:15;7197:398;7399:2;7381:21;;;7438:2;7418:18;;;7411:30;7477:34;7472:2;7457:18;;7450:62;-1:-1:-1;;;7543:2:1;7528:18;;7521:32;7585:3;7570:19;;7197:398::o;8026:644::-;8306:3;8344:6;8338:13;8360:66;8419:6;8414:3;8407:4;8399:6;8395:17;8360:66;:::i;:::-;-1:-1:-1;;;8448:16:1;;;8473:22;;;8520:13;;8542:78;8520:13;8607:1;8596:13;;8589:4;8577:17;;8542:78;:::i;:::-;8640:20;8662:1;8636:28;;8026:644;-1:-1:-1;;;;8026:644:1:o;8675:648::-;8755:6;8808:2;8796:9;8787:7;8783:23;8779:32;8776:52;;;8824:1;8821;8814:12;8776:52;8857:9;8851:16;8890:18;8882:6;8879:30;8876:50;;;8922:1;8919;8912:12;8876:50;8945:22;;8998:4;8990:13;;8986:27;-1:-1:-1;8976:55:1;;9027:1;9024;9017:12;8976:55;9056:2;9050:9;9081:48;9097:31;9125:2;9097:31;:::i;9081:48::-;9152:2;9145:5;9138:17;9192:7;9187:2;9182;9178;9174:11;9170:20;9167:33;9164:53;;;9213:1;9210;9203:12;9164:53;9226:67;9290:2;9285;9278:5;9274:14;9269:2;9265;9261:11;9226:67;:::i;:::-;9312:5;8675:648;-1:-1:-1;;;;;8675:648:1:o;9328:414::-;9530:2;9512:21;;;9569:2;9549:18;;;9542:30;9608:34;9603:2;9588:18;;9581:62;-1:-1:-1;;;9674:2:1;9659:18;;9652:48;9732:3;9717:19;;9328:414::o;10490:127::-;10551:10;10546:3;10542:20;10539:1;10532:31;10582:4;10579:1;10572:15;10606:4;10603:1;10596:15;10622:125;10687:9;;;10708:10;;;10705:36;;;10721:18;;:::i;12684:168::-;12757:9;;;12788;;12805:15;;;12799:22;;12785:37;12775:71;;12826:18;;:::i;12989:217::-;13029:1;13055;13045:132;;13099:10;13094:3;13090:20;13087:1;13080:31;13134:4;13131:1;13124:15;13162:4;13159:1;13152:15;13045:132;-1:-1:-1;13191:9:1;;12989:217::o;13211:128::-;13278:9;;;13299:11;;;13296:37;;;13313:18;;:::i;14321:648::-;14601:3;14639:6;14633:13;14655:66;14714:6;14709:3;14702:4;14694:6;14690:17;14655:66;:::i;:::-;-1:-1:-1;;;14743:16:1;;;14768:26;;;14819:13;;14841:78;14819:13;14906:1;14895:13;;14888:4;14876:17;;14841:78;:::i;:::-;14939:20;14961:1;14935:28;;14321:648;-1:-1:-1;;;;14321:648:1:o;22274:245::-;22341:6;22394:2;22382:9;22373:7;22369:23;22365:32;22362:52;;;22410:1;22407;22400:12;22362:52;22442:9;22436:16;22461:28;22483:5;22461:28;:::i;22524:531::-;22812:1;22808;22803:3;22799:11;22795:19;22787:6;22783:32;22772:9;22765:51;22852:6;22847:2;22836:9;22832:18;22825:34;22895:6;22890:2;22879:9;22875:18;22868:34;22938:6;22933:2;22922:9;22918:18;22911:34;22982:3;22976;22965:9;22961:19;22954:32;22746:4;23003:46;23044:3;23033:9;23029:19;23021:6;23003:46;:::i;:::-;22995:54;22524:531;-1:-1:-1;;;;;;;22524:531:1:o;23060:249::-;23129:6;23182:2;23170:9;23161:7;23157:23;23153:32;23150:52;;;23198:1;23195;23188:12;23150:52;23230:9;23224:16;23249:30;23273:5;23249:30;:::i;23314:135::-;23353:3;23374:17;;;23371:43;;23394:18;;:::i;:::-;-1:-1:-1;23441:1:1;23430:13;;23314:135::o;23454:127::-;23515:10;23510:3;23506:20;23503:1;23496:31;23546:4;23543:1;23536:15;23570:4;23567:1;23560:15;23586:489;-1:-1:-1;;;;;23855:15:1;;;23837:34;;23907:15;;23902:2;23887:18;;23880:43;23954:2;23939:18;;23932:34;;;24002:3;23997:2;23982:18;;23975:31;;;23780:4;;24023:46;;24049:19;;24041:6;24023:46;:::i;:::-;24015:54;23586:489;-1:-1:-1;;;;;;23586:489:1:o;24499:136::-;24538:3;24566:5;24556:39;;24575:18;;:::i;:::-;-1:-1:-1;;;24611:18:1;;24499:136::o

Swarm Source

ipfs://b45a7ac41c9ccdda67e0915e2c6a097105a7839e3f38cfee96a558663330742f

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