Token

The Sect Conversion (SECTCON)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

38 SECTCON

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xda108a65a6ebdf23408d87107f6ff597f273d7b3

Filtered by Token Holder

0x689eadFE7d071802084642e5719FB493aC47fCCC

Balance

1 SECTCON

0x689eadfe7d071802084642e5719fb493ac47fccc

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

TheSect

Compiler Version

v0.8.21+commit.d9974bed

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-08-03
*/

//SPDX-License-Identifier: UNLICENSED

pragma solidity >=0.8.19;

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;
    }
}

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(
        uint256 a,
        uint256 b
    ) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

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

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

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

library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

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

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

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() {
        _setOwner(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _setOwner(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"
        );
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

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

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

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

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(
            data
        );
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

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

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);
}

abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

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

contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

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

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

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

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(ERC165, IERC165) returns (bool) {
        return
            interfaceId == type(IERC721).interfaceId ||
            interfaceId == type(IERC721Metadata).interfaceId ||
            super.supportsInterface(interfaceId);
    }

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

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(
        uint256 tokenId
    ) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(
            owner != address(0),
            "ERC721: owner query for nonexistent token"
        );
        return owner;
    }

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

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

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

        string memory baseURI = _baseURI();
        return
            bytes(baseURI).length > 0
                ? string(abi.encodePacked(baseURI, tokenId.toString()))
                : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

        _balances[to] += 1;
        _owners[tokenId] = to;

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

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

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

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

        _balances[owner] -= 1;
        delete _owners[tokenId];

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

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

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

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

abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(
        bytes4 interfaceId
    ) public view virtual override(IERC165, ERC721) returns (bool) {
        return
            interfaceId == type(IERC721Enumerable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(
        address owner,
        uint256 index
    ) public view virtual override returns (uint256) {
        require(
            index < ERC721.balanceOf(owner),
            "ERC721Enumerable: owner index out of bounds"
        );
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(
        uint256 index
    ) public view virtual override returns (uint256) {
        require(
            index < ERC721Enumerable.totalSupply(),
            "ERC721Enumerable: global index out of bounds"
        );
        return _allTokens[index];
    }

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

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(
        address from,
        uint256 tokenId
    ) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

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

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

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

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

interface IOperatorFilterRegistry {
    /**
     * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns
     *         true if supplied registrant address is not registered.
     */
    function isOperatorAllowed(
        address registrant,
        address operator
    ) external view returns (bool);

    /**
     * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner.
     */
    function register(address registrant) external;

    /**
     * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes.
     */
    function registerAndSubscribe(
        address registrant,
        address subscription
    ) external;

    /**
     * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another
     *         address without subscribing.
     */
    function registerAndCopyEntries(
        address registrant,
        address registrantToCopy
    ) external;

    /**
     * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner.
     *         Note that this does not remove any filtered addresses or codeHashes.
     *         Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes.
     */
    function unregister(address addr) external;

    /**
     * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered.
     */
    function updateOperator(
        address registrant,
        address operator,
        bool filtered
    ) external;

    /**
     * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates.
     */
    function updateOperators(
        address registrant,
        address[] calldata operators,
        bool filtered
    ) external;

    /**
     * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered.
     */
    function updateCodeHash(
        address registrant,
        bytes32 codehash,
        bool filtered
    ) external;

    /**
     * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates.
     */
    function updateCodeHashes(
        address registrant,
        bytes32[] calldata codeHashes,
        bool filtered
    ) external;

    /**
     * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous
     *         subscription if present.
     *         Note that accounts with subscriptions may go on to subscribe to other accounts - in this case,
     *         subscriptions will not be forwarded. Instead the former subscription's existing entries will still be
     *         used.
     */
    function subscribe(
        address registrant,
        address registrantToSubscribe
    ) external;

    /**
     * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes.
     */
    function unsubscribe(address registrant, bool copyExistingEntries) external;

    /**
     * @notice Get the subscription address of a given registrant, if any.
     */
    function subscriptionOf(address addr) external returns (address registrant);

    /**
     * @notice Get the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscribers(
        address registrant
    ) external returns (address[] memory);

    /**
     * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant.
     *         Note that order is not guaranteed as updates are made.
     */
    function subscriberAt(
        address registrant,
        uint256 index
    ) external returns (address);

    /**
     * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr.
     */
    function copyEntriesOf(
        address registrant,
        address registrantToCopy
    ) external;

    /**
     * @notice Returns true if operator is filtered by a given address or its subscription.
     */
    function isOperatorFiltered(
        address registrant,
        address operator
    ) external returns (bool);

    /**
     * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription.
     */
    function isCodeHashOfFiltered(
        address registrant,
        address operatorWithCode
    ) external returns (bool);

    /**
     * @notice Returns true if a codeHash is filtered by a given address or its subscription.
     */
    function isCodeHashFiltered(
        address registrant,
        bytes32 codeHash
    ) external returns (bool);

    /**
     * @notice Returns a list of filtered operators for a given address or its subscription.
     */
    function filteredOperators(
        address addr
    ) external returns (address[] memory);

    /**
     * @notice Returns the set of filtered codeHashes for a given address or its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashes(
        address addr
    ) external returns (bytes32[] memory);

    /**
     * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredOperatorAt(
        address registrant,
        uint256 index
    ) external returns (address);

    /**
     * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or
     *         its subscription.
     *         Note that order is not guaranteed as updates are made.
     */
    function filteredCodeHashAt(
        address registrant,
        uint256 index
    ) external returns (bytes32);

    /**
     * @notice Returns true if an address has registered
     */
    function isRegistered(address addr) external returns (bool);

    /**
     * @dev Convenience method to compute the code hash of an arbitrary contract
     */
    function codeHashOf(address addr) external returns (bytes32);
}

address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E;
address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6;

abstract contract OperatorFilterer {
    /// @dev Emitted when an operator is not allowed.
    error OperatorNotAllowed(address operator);

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS);

    /// @dev The constructor that is called when the contract is being deployed.
    constructor(address subscriptionOrRegistrantToCopy, bool subscribe) {
        // If an inheriting token contract is deployed to a network without the registry deployed, the modifier
        // will not revert, but the contract will need to be registered with the registry once it is deployed in
        // order for the modifier to filter addresses.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            if (subscribe) {
                OPERATOR_FILTER_REGISTRY.registerAndSubscribe(
                    address(this),
                    subscriptionOrRegistrantToCopy
                );
            } else {
                if (subscriptionOrRegistrantToCopy != address(0)) {
                    OPERATOR_FILTER_REGISTRY.registerAndCopyEntries(
                        address(this),
                        subscriptionOrRegistrantToCopy
                    );
                } else {
                    OPERATOR_FILTER_REGISTRY.register(address(this));
                }
            }
        }
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    modifier onlyAllowedOperator(address from) virtual {
        // Allow spending tokens from addresses with balance
        // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred
        // from an EOA.
        if (from != msg.sender) {
            _checkFilterOperator(msg.sender);
        }
        _;
    }

    /**
     * @dev A helper function to check if an operator approval is allowed.
     */
    modifier onlyAllowedOperatorApproval(address operator) virtual {
        _checkFilterOperator(operator);
        _;
    }

    /**
     * @dev A helper function to check if an operator is allowed.
     */
    function _checkFilterOperator(address operator) internal view virtual {
        // Check registry code length to facilitate testing in environments without a deployed registry.
        if (address(OPERATOR_FILTER_REGISTRY).code.length > 0) {
            // under normal circumstances, this function will revert rather than return false, but inheriting contracts
            // may specify their own OperatorFilterRegistry implementations, which may behave differently
            if (
                !OPERATOR_FILTER_REGISTRY.isOperatorAllowed(
                    address(this),
                    operator
                )
            ) {
                revert OperatorNotAllowed(operator);
            }
        }
    }
}

abstract contract DefaultOperatorFilterer is OperatorFilterer {
    /// @dev The constructor that is called when the contract is being deployed.
    constructor() OperatorFilterer(CANONICAL_CORI_SUBSCRIPTION, true) {}
}

contract TheSect is DefaultOperatorFilterer, ERC721Enumerable, Ownable {
    using Strings for uint256;
    using SafeMath for uint256;
    using Counters for Counters.Counter;

    // Constants
    string public baseExtension = ".json";

    // Supply
    uint256 public maxSupply = 100;
    uint256 public lastSupply = maxSupply;
    uint256 public maxMintAmount = 1;

    // Role
    address public CultLeader = 0x063EA9A84b21e8862E2EB0193FAbAcc9c7ae5A49;

    // Lists
    uint256[100] public remainingIds;
    mapping(uint256 => address) public minters;

    // Whitelist Mappings
    mapping(address => bool) public whitelist;
    mapping(address => bool) public hasMinted;

    // Params
    bool public paused = true;
    string private _baseTokenURI;
    address private _wallet;

    // TradeLock
    bool public tradeLock = true;

    modifier tradeLockModifier() {
        require(!tradeLock);
        _;
    }

    modifier onlyLeader() {
        require(msg.sender == CultLeader);
        _;
    }

    // Constructor
    constructor() ERC721("The Sect Conversion", "SECTCON") {
        _baseTokenURI = "ipfs://bafybeih2nqaizw53drbdb3g2fa6j7v6y44b2yei4dio5moiwrqsosuqfb4/";
        _wallet = msg.sender;
    }

    // URI Handling
    function _baseURI() internal view virtual override returns (string memory) {
        return _baseTokenURI;
    }

    // Setters
    function setBaseURI(string memory baseURI) external onlyOwner {
        _baseTokenURI = baseURI;
    }

    function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
        maxMintAmount = _newmaxMintAmount;
    }

    function setBaseExtension(
        string memory _newBaseExtension
    ) public onlyOwner {
        baseExtension = _newBaseExtension;
    }

    function pause(bool _state) public onlyOwner {
        paused = _state;
    }

    function setTradeLock(bool _state) public onlyOwner {
        tradeLock = _state;
    }

    function setWhitelistedAddresses(
        address[] memory _whitelistedAddresses,
        bool _state
    ) public onlyOwner {
        for (uint256 i = 0; i < _whitelistedAddresses.length; i++) {
            whitelist[_whitelistedAddresses[i]] = _state;
        }
    }

    // Minting
    function mint() public {
        // Checks
        require(!paused, "TheSect: minting has not started yet");
        require(lastSupply >= 1, "TheSect: the collection is sold out");
        // Whitelist
        require(whitelist[msg.sender], "TheSect: you are not whitelisted");
        require(!hasMinted[msg.sender], "TheSect: you already minted");
        hasMinted[msg.sender] = true;
        // Minting
        _randomMint(msg.sender);
    }

    function Induction(address _acolyte) external onlyLeader {
        // Checks
        require(_acolyte != address(0), "TheSect: zero address");
        require(lastSupply != 0, "TheSect: the collection is sold out");
        _randomMint(_acolyte);
    }

    function MassConversion(
        address[] memory _flock
    ) external onlyLeader {
        // Checks
        require(lastSupply != 0, "TheSect: the collection is sold out");
        require(_flock.length <= lastSupply, "TheSect: not enough supply");
        // Minting
        for (uint256 i = 0; i < _flock.length; i++) {
            _randomMint(_flock[i]);
        }
    }

    // Random mint
    function _randomMint(address _target) internal returns (uint256) {
        // Get Random id to mint
        uint256 _index = _getRandom() % lastSupply;
        uint256 _realIndex = getValue(_index) + 1;
        // Reduce supply
        lastSupply--;
        // Replace used id by last
        remainingIds[_index] = getValue(lastSupply);
        // Mint
        _safeMint(_target, _realIndex);
        // Save Original minters
        minters[_realIndex] = msg.sender;
        return _realIndex;
    }

    // Mint for reserved spots
    function _regularMint() internal returns (uint256) {
        // Get Actual id to mint
        uint256 _index = totalSupply();
        uint256 _realIndex = getValue(_index) + 1;
        // Reduce supply
        lastSupply--;
        // Replace used id by last
        remainingIds[_index] = getValue(lastSupply);
        // Mint
        _safeMint(msg.sender, _realIndex);
        // Save Original minters
        minters[_realIndex] = msg.sender;
        return _realIndex;
    }

    // Get Token List
    function getTokenIds(
        address _owner
    ) public view returns (uint256[] memory) {
        // Count owned Token
        uint256 ownerTokenCount = balanceOf(_owner);
        uint256[] memory tokenIds = new uint256[](ownerTokenCount);
        // Get ids of owned Token
        for (uint256 i; i < ownerTokenCount; i++) {
            tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
        }
        return tokenIds;
    }

    // Return compiled Token URI
    function tokenURI(
        uint256 _id
    ) public view virtual override returns (string memory) {
        require(_exists(_id), "TheSect: URI query for nonexistent token");
        string memory currentBaseURI = _baseURI();
        return
            bytes(currentBaseURI).length > 0
                ? string(
                    abi.encodePacked(
                        currentBaseURI,
                        _id.toString(),
                        baseExtension
                    )
                )
                : "";
    }

    // Get value from a remaining id node
    function getValue(uint256 _index) internal view returns (uint256) {
        if (remainingIds[_index] != 0) return remainingIds[_index];
        else return _index;
    }

    // Create a random id for minting
    function _getRandom() internal view returns (uint256) {
        return
            uint256(
                keccak256(
                    abi.encodePacked(
                        block.prevrandao,
                        block.timestamp,
                        lastSupply
                    )
                )
            );
    }

    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    function setApprovalForAll(
        address operator,
        bool approved
    )
        public
        override(IERC721, ERC721)
        onlyAllowedOperatorApproval(operator)
        tradeLockModifier
    {
        super.setApprovalForAll(operator, approved);
    }

    function approve(
        address operator,
        uint256 tokenId
    )
        public
        override(IERC721, ERC721)
        onlyAllowedOperatorApproval(operator)
        tradeLockModifier
    {
        super.approve(operator, tokenId);
    }

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    )
        public
        override(IERC721, ERC721)
        onlyAllowedOperator(from)
        tradeLockModifier
    {
        super.transferFrom(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    )
        public
        override(IERC721, ERC721)
        onlyAllowedOperator(from)
        tradeLockModifier
    {
        super.safeTransferFrom(from, to, tokenId);
    }

    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory data
    )
        public
        override(IERC721, ERC721)
        onlyAllowedOperator(from)
        tradeLockModifier
    {
        super.safeTransferFrom(from, to, tokenId, data);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"CultLeader","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_acolyte","type":"address"}],"name":"Induction","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_flock","type":"address[]"}],"name":"MassConversion","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseExtension","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":[{"internalType":"address","name":"_owner","type":"address"}],"name":"getTokenIds","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"hasMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"lastSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"minters","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"remainingIds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseExtension","type":"string"}],"name":"setBaseExtension","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"setTradeLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_whitelistedAddresses","type":"address[]"},{"internalType":"bool","name":"_state","type":"bool"}],"name":"setWhitelistedAddresses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newmaxMintAmount","type":"uint256"}],"name":"setmaxMintAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tradeLock","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

58429:7776:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41972:266;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;41972:266:0;;;;;;;;60259:79;;;;;;:::i;:::-;;:::i;:::-;;29565:100;;;:::i;:::-;;;;;;;:::i;31224:274::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2066:32:1;;;2048:51;;2036:2;2021:18;31224:274:0;1902:203:1;65051:258:0;;;;;;:::i;:::-;;:::i;60743:456::-;;;:::i;42716:113::-;42804:10;:17;42716:113;;;2693:25:1;;;2681:2;2666:18;42716:113:0;2547:177:1;61472:386:0;;;;;;:::i;:::-;;:::i;58776:32::-;;;;;;65317:273;;;;;;:::i;:::-;;:::i;61207:257::-;;;;;;:::i;:::-;;:::i;42322:318::-;;;;;;:::i;:::-;;:::i;60443:276::-;;;;;;:::i;:::-;;:::i;59088:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;64615:143;;;:::i;55397:::-;;55110:42;55397:143;;65598:281;;;;;;:::i;:::-;;:::i;42906:286::-;;;;;;:::i;:::-;;:::i;59865:104::-;;;;;;:::i;:::-;;:::i;59153:25::-;;;;;;;;;29206:292;;;;;;:::i;:::-;;:::i;58830:70::-;;;;;-1:-1:-1;;;;;58830:70:0;;;28883:261;;;;;;:::i;:::-;;:::i;11013:94::-;;;:::i;60346:89::-;;;;;;:::i;:::-;;:::i;59270:28::-;;;;;-1:-1:-1;;;59270:28:0;;;;;;59977:122;;;;;;:::i;:::-;;:::i;58962:42::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;58962:42:0;;;10362:87;10435:6;;-1:-1:-1;;;;;10435:6:0;10362:87;;29734:104;;;:::i;59040:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;64766:277;;;;;;:::i;:::-;;:::i;65887:315::-;;;;;;:::i;:::-;;:::i;58634:37::-;;;:::i;63441:550::-;;;;;;:::i;:::-;;:::i;62962:437::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;58695:30::-;;;;;;60107:144;;;;;;:::i;:::-;;:::i;31961:189::-;;;;;;:::i;:::-;-1:-1:-1;;;;;32107:25:0;;;32083:4;32107:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;31961:189;58923:32;;;;;;:::i;:::-;;:::i;11262:229::-;;;;;;:::i;:::-;;:::i;58732:37::-;;;;;;41972:266;42090:4;-1:-1:-1;;;;;;42127:50:0;;-1:-1:-1;;;42127:50:0;;:103;;;42194:36;42218:11;42194:23;:36::i;:::-;42107:123;41972:266;-1:-1:-1;;41972:266:0:o;60259:79::-;10435:6;;-1:-1:-1;;;;;10435:6:0;9800:10;10582:23;10574:68;;;;-1:-1:-1;;;10574:68:0;;;;;;;:::i;:::-;;;;;;;;;60315:6:::1;:15:::0;;-1:-1:-1;;60315:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;60259:79::o;29565:100::-;29619:13;29652:5;29645:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29565:100;:::o;31224:274::-;31316:7;34921:16;;;:7;:16;;;;;;-1:-1:-1;;;;;34921:16:0;31336:110;;;;-1:-1:-1;;;31336:110:0;;9173:2:1;31336:110:0;;;9155:21:1;9212:2;9192:18;;;9185:30;9251:34;9231:18;;;9224:62;-1:-1:-1;;;9302:18:1;;;9295:42;9354:19;;31336:110:0;8971:408:1;31336:110:0;-1:-1:-1;31466:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;31466:24:0;;31224:274::o;65051:258::-;65216:8;57313:30;57334:8;57313:20;:30::i;:::-;59356:9:::1;::::0;-1:-1:-1;;;59356:9:0;::::1;;;59355:10;59347:19;;;::::0;::::1;;65269:32:::2;65283:8;65293:7;65269:13;:32::i;:::-;65051:258:::0;;;:::o;60743:456::-;60805:6;;;;60804:7;60796:56;;;;-1:-1:-1;;;60796:56:0;;9586:2:1;60796:56:0;;;9568:21:1;9625:2;9605:18;;;9598:30;9664:34;9644:18;;;9637:62;-1:-1:-1;;;9715:18:1;;;9708:34;9759:19;;60796:56:0;9384:400:1;60796:56:0;60885:1;60871:10;;:15;;60863:63;;;;-1:-1:-1;;;60863:63:0;;;;;;;:::i;:::-;60977:10;60967:21;;;;:9;:21;;;;;;;;60959:66;;;;-1:-1:-1;;;60959:66:0;;10395:2:1;60959:66:0;;;10377:21:1;;;10414:18;;;10407:30;10473:34;10453:18;;;10446:62;10525:18;;60959:66:0;10193:356:1;60959:66:0;61055:10;61045:21;;;;:9;:21;;;;;;;;61044:22;61036:62;;;;-1:-1:-1;;;61036:62:0;;10756:2:1;61036:62:0;;;10738:21:1;10795:2;10775:18;;;10768:30;10834:29;10814:18;;;10807:57;10881:18;;61036:62:0;10554:351:1;61036:62:0;61119:10;61109:21;;;;:9;:21;;;;;:28;;-1:-1:-1;;61109:28:0;61133:4;61109:28;;;61168:23;;:11;:23::i;:::-;;60743:456::o;61472:386::-;59449:10;;-1:-1:-1;;;;;59449:10:0;59435;:24;59427:33;;;;;;61595:10:::1;;61609:1;61595:15:::0;61587:63:::1;;;;-1:-1:-1::0;;;61587:63:0::1;;;;;;;:::i;:::-;61686:10;;61669:6;:13;:27;;61661:66;;;::::0;-1:-1:-1;;;61661:66:0;;11112:2:1;61661:66:0::1;::::0;::::1;11094:21:1::0;11151:2;11131:18;;;11124:30;11190:28;11170:18;;;11163:56;11236:18;;61661:66:0::1;10910:350:1::0;61661:66:0::1;61763:9;61758:93;61782:6;:13;61778:1;:17;61758:93;;;61817:22;61829:6;61836:1;61829:9;;;;;;;;:::i;:::-;;;;;;;61817:11;:22::i;:::-;-1:-1:-1::0;61797:3:0;::::1;::::0;::::1;:::i;:::-;;;;61758:93;;;;61472:386:::0;:::o;65317:273::-;65496:4;-1:-1:-1;;;;;57039:18:0;;57047:10;57039:18;57035:83;;57074:32;57095:10;57074:20;:32::i;:::-;59356:9:::1;::::0;-1:-1:-1;;;59356:9:0;::::1;;;59355:10;59347:19;;;::::0;::::1;;65545:37:::2;65564:4;65570:2;65574:7;65545:18;:37::i;:::-;65317:273:::0;;;;:::o;61207:257::-;59449:10;;-1:-1:-1;;;;;59449:10:0;59435;:24;59427:33;;;;;;-1:-1:-1;;;;;61302:22:0;::::1;61294:56;;;::::0;-1:-1:-1;;;61294:56:0;;11871:2:1;61294:56:0::1;::::0;::::1;11853:21:1::0;11910:2;11890:18;;;11883:30;-1:-1:-1;;;11929:18:1;;;11922:51;11990:18;;61294:56:0::1;11669:345:1::0;61294:56:0::1;61369:10;;61383:1;61369:15:::0;61361:63:::1;;;;-1:-1:-1::0;;;61361:63:0::1;;;;;;;:::i;:::-;61435:21;61447:8;61435:11;:21::i;42322:318::-:0;42444:7;42494:23;42511:5;42494:16;:23::i;:::-;42486:5;:31;42464:124;;;;-1:-1:-1;;;42464:124:0;;12221:2:1;42464:124:0;;;12203:21:1;12260:2;12240:18;;;12233:30;12299:34;12279:18;;;12272:62;-1:-1:-1;;;12350:18:1;;;12343:41;12401:19;;42464:124:0;12019:407:1;42464:124:0;-1:-1:-1;;;;;;42606:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;42322:318::o;60443:276::-;10435:6;;-1:-1:-1;;;;;10435:6:0;9800:10;10582:23;10574:68;;;;-1:-1:-1;;;10574:68:0;;;;;;;:::i;:::-;60587:9:::1;60582:130;60606:21;:28;60602:1;:32;60582:130;;;60694:6;60656:9;:35;60666:21;60688:1;60666:24;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;60656:35:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;60656:35:0;:44;;-1:-1:-1;;60656:44:0::1;::::0;::::1;;::::0;;;::::1;::::0;;60636:3;::::1;::::0;::::1;:::i;:::-;;;;60582:130;;64615:143:::0;10435:6;;-1:-1:-1;;;;;10435:6:0;9800:10;10582:23;10574:68;;;;-1:-1:-1;;;10574:68:0;;;;;;;:::i;:::-;64713:37:::1;::::0;64681:21:::1;::::0;64721:10:::1;::::0;64713:37;::::1;;;::::0;64681:21;;64663:15:::1;64713:37:::0;64663:15;64713:37;64681:21;64721:10;64713:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;65598:281:::0;65781:4;-1:-1:-1;;;;;57039:18:0;;57047:10;57039:18;57035:83;;57074:32;57095:10;57074:20;:32::i;:::-;59356:9:::1;::::0;-1:-1:-1;;;59356:9:0;::::1;;;59355:10;59347:19;;;::::0;::::1;;65830:41:::2;65853:4;65859:2;65863:7;65830:22;:41::i;42906:286::-:0;42997:7;43047:30;42804:10;:17;;42716:113;43047:30;43039:5;:38;43017:132;;;;-1:-1:-1;;;43017:132:0;;12633:2:1;43017:132:0;;;12615:21:1;12672:2;12652:18;;;12645:30;12711:34;12691:18;;;12684:62;-1:-1:-1;;;12762:18:1;;;12755:42;12814:19;;43017:132:0;12431:408:1;43017:132:0;43167:10;43178:5;43167:17;;;;;;;;:::i;:::-;;;;;;;;;43160:24;;42906:286;;;:::o;59865:104::-;10435:6;;-1:-1:-1;;;;;10435:6:0;9800:10;10582:23;10574:68;;;;-1:-1:-1;;;10574:68:0;;;;;;;:::i;:::-;59938:13:::1;:23;59954:7:::0;59938:13;:23:::1;:::i;29206:292::-:0;29294:7;29330:16;;;:7;:16;;;;;;-1:-1:-1;;;;;29330:16:0;;29357:110;;;;-1:-1:-1;;;29357:110:0;;15250:2:1;29357:110:0;;;15232:21:1;15289:2;15269:18;;;15262:30;15328:34;15308:18;;;15301:62;-1:-1:-1;;;15379:18:1;;;15372:39;15428:19;;29357:110:0;15048:405:1;28883:261:0;28971:7;-1:-1:-1;;;;;29013:19:0;;28991:111;;;;-1:-1:-1;;;28991:111:0;;15660:2:1;28991:111:0;;;15642:21:1;15699:2;15679:18;;;15672:30;15738:34;15718:18;;;15711:62;-1:-1:-1;;;15789:18:1;;;15782:40;15839:19;;28991:111:0;15458:406:1;28991:111:0;-1:-1:-1;;;;;;29120:16:0;;;;;:9;:16;;;;;;;28883:261::o;11013:94::-;10435:6;;-1:-1:-1;;;;;10435:6:0;9800:10;10582:23;10574:68;;;;-1:-1:-1;;;10574:68:0;;;;;;;:::i;:::-;11078:21:::1;11096:1;11078:9;:21::i;:::-;11013:94::o:0;60346:89::-;10435:6;;-1:-1:-1;;;;;10435:6:0;9800:10;10582:23;10574:68;;;;-1:-1:-1;;;10574:68:0;;;;;;;:::i;:::-;60409:9:::1;:18:::0;;;::::1;;-1:-1:-1::0;;;60409:18:0::1;-1:-1:-1::0;;;;60409:18:0;;::::1;::::0;;;::::1;::::0;;60346:89::o;59977:122::-;10435:6;;-1:-1:-1;;;;;10435:6:0;9800:10;10582:23;10574:68;;;;-1:-1:-1;;;10574:68:0;;;;;;;:::i;:::-;60058:13:::1;:33:::0;59977:122::o;29734:104::-;29790:13;29823:7;29816:14;;;;;:::i;64766:277::-;64939:8;57313:30;57334:8;57313:20;:30::i;:::-;59356:9:::1;::::0;-1:-1:-1;;;59356:9:0;::::1;;;59355:10;59347:19;;;::::0;::::1;;64992:43:::2;65016:8;65026;64992:23;:43::i;65887:315::-:0;66098:4;-1:-1:-1;;;;;57039:18:0;;57047:10;57039:18;57035:83;;57074:32;57095:10;57074:20;:32::i;:::-;59356:9:::1;::::0;-1:-1:-1;;;59356:9:0;::::1;;;59355:10;59347:19;;;::::0;::::1;;66147:47:::2;66170:4;66176:2;66180:7;66189:4;66147:22;:47::i;:::-;65887:315:::0;;;;;:::o;58634:37::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;63441:550::-;34897:4;34921:16;;;:7;:16;;;;;;63526:13;;-1:-1:-1;;;;;34921:16:0;63552:65;;;;-1:-1:-1;;;63552:65:0;;16071:2:1;63552:65:0;;;16053:21:1;16110:2;16090:18;;;16083:30;16149:34;16129:18;;;16122:62;-1:-1:-1;;;16200:18:1;;;16193:38;16248:19;;63552:65:0;15869:404:1;63552:65:0;63628:28;63659:10;:8;:10::i;:::-;63628:41;;63731:1;63706:14;63700:28;:32;:283;;;;;;;;;;;;;;;;;63824:14;63865;:3;:12;:14::i;:::-;63906:13;63781:161;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;63700:283;63680:303;63441:550;-1:-1:-1;;;63441:550:0:o;62962:437::-;63036:16;63095:23;63121:17;63131:6;63121:9;:17::i;:::-;63095:43;;63149:25;63191:15;63177:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;63177:30:0;;63149:58;;63258:9;63253:113;63273:15;63269:1;:19;63253:113;;;63324:30;63344:6;63352:1;63324:19;:30::i;:::-;63310:8;63319:1;63310:11;;;;;;;;:::i;:::-;;;;;;;;;;:44;63290:3;;;;:::i;:::-;;;;63253:113;;;-1:-1:-1;63383:8:0;62962:437;-1:-1:-1;;;62962:437:0:o;60107:144::-;10435:6;;-1:-1:-1;;;;;10435:6:0;9800:10;10582:23;10574:68;;;;-1:-1:-1;;;10574:68:0;;;;;;;:::i;:::-;60210:13:::1;:33;60226:17:::0;60210:13;:33:::1;:::i;58923:32::-:0;;;;;;;;;;;;;;;-1:-1:-1;58923:32:0;:::o;11262:229::-;10435:6;;-1:-1:-1;;;;;10435:6:0;9800:10;10582:23;10574:68;;;;-1:-1:-1;;;10574:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;11365:22:0;::::1;11343:110;;;::::0;-1:-1:-1;;;11343:110:0;;17741:2:1;11343:110:0::1;::::0;::::1;17723:21:1::0;17780:2;17760:18;;;17753:30;17819:34;17799:18;;;17792:62;-1:-1:-1;;;17870:18:1;;;17863:36;17916:19;;11343:110:0::1;17539:402:1::0;11343:110:0::1;11464:19;11474:8;11464:9;:19::i;28498:321::-:0;28616:4;-1:-1:-1;;;;;;28653:40:0;;-1:-1:-1;;;28653:40:0;;:105;;-1:-1:-1;;;;;;;28710:48:0;;-1:-1:-1;;;28710:48:0;28653:105;:158;;;-1:-1:-1;;;;;;;;;;21481:40:0;;;28775:36;21356:173;57456:740;55110:42;57647:45;:49;57643:546;;57964:128;;-1:-1:-1;;;57964:128:0;;58037:4;57964:128;;;18158:34:1;-1:-1:-1;;;;;18228:15:1;;18208:18;;;18201:43;55110:42:0;;57964;;18093:18:1;;57964:128:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57941:237;;58134:28;;-1:-1:-1;;;58134:28:0;;-1:-1:-1;;;;;2066:32:1;;58134:28:0;;;2048:51:1;2021:18;;58134:28:0;1902:203:1;30747:411:0;30828:13;30844:23;30859:7;30844:14;:23::i;:::-;30828:39;;30892:5;-1:-1:-1;;;;;30886:11:0;:2;-1:-1:-1;;;;;30886:11:0;;30878:57;;;;-1:-1:-1;;;30878:57:0;;18707:2:1;30878:57:0;;;18689:21:1;18746:2;18726:18;;;18719:30;18785:34;18765:18;;;18758:62;-1:-1:-1;;;18836:18:1;;;18829:31;18877:19;;30878:57:0;18505:397:1;30878:57:0;9800:10;-1:-1:-1;;;;;30970:21:0;;;;:62;;-1:-1:-1;30995:37:0;31012:5;9800:10;31961:189;:::i;30995:37::-;30948:168;;;;-1:-1:-1;;;30948:168:0;;19109:2:1;30948:168:0;;;19091:21:1;19148:2;19128:18;;;19121:30;19187:34;19167:18;;;19160:62;19258:26;19238:18;;;19231:54;19302:19;;30948:168:0;18907:420:1;30948:168:0;31129:21;31138:2;31142:7;31129:8;:21::i;61886:514::-;62028:10;;64404:161;;;64447:16;64404:161;;;;21067:19:1;;;;64490:15:0;21102:12:1;;;21095:28;21139:12;;;;21132:28;;;64404:161:0;;;;;;;;;;21176:12:1;;;;64404:161:0;;;64372:212;;;;;61942:7;;;;62013:25;;;;:::i;:::-;61996:42;;62049:18;62070:16;62079:6;62070:8;:16::i;:::-;:20;;62089:1;62070:20;:::i;:::-;62127:10;:12;;62049:41;;-1:-1:-1;62127:10:0;:12;;;:::i;:::-;;;;;;62209:20;62218:10;;62209:8;:20::i;:::-;62186:12;62199:6;62186:20;;;;;;;:::i;:::-;;:43;62257:30;62267:7;62276:10;62257:9;:30::i;:::-;62332:19;;;;:7;:19;;;;;:32;;-1:-1:-1;;;;;;62332:32:0;62354:10;62332:32;;;62340:10;61886:514;-1:-1:-1;;;61886:514:0:o;32217:376::-;32426:41;9800:10;32459:7;32426:18;:41::i;:::-;32404:140;;;;-1:-1:-1;;;32404:140:0;;;;;;;:::i;:::-;32557:28;32567:4;32573:2;32577:7;32557:9;:28::i;32664:185::-;32802:39;32819:4;32825:2;32829:7;32802:39;;;;;;;;;;;;:16;:39::i;11499:173::-;11574:6;;;-1:-1:-1;;;;;11591:17:0;;;-1:-1:-1;;;;;;11591:17:0;;;;;;;11624:40;;11574:6;;;11591:17;11574:6;;11624:40;;11555:16;;11624:40;11544:128;11499:173;:::o;31570:320::-;9800:10;-1:-1:-1;;;;;31698:24:0;;;31690:62;;;;-1:-1:-1;;;31690:62:0;;20472:2:1;31690:62:0;;;20454:21:1;20511:2;20491:18;;;20484:30;20550:27;20530:18;;;20523:55;20595:18;;31690:62:0;20270:349:1;31690:62:0;9800:10;31765:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;31765:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;31765:53:0;;;;;;;;;;31834:48;;540:41:1;;;31765:42:0;;9800:10;31834:48;;513:18:1;31834:48:0;;;;;;;31570:320;;:::o;32920:365::-;33109:41;9800:10;33142:7;33109:18;:41::i;:::-;33087:140;;;;-1:-1:-1;;;33087:140:0;;;;;;;:::i;:::-;33238:39;33252:4;33258:2;33262:7;33271:5;33238:13;:39::i;59727:114::-;59787:13;59820;59813:20;;;;;:::i;7903:723::-;7959:13;8180:5;8189:1;8180:10;8176:53;;-1:-1:-1;;8207:10:0;;;;;;;;;;;;-1:-1:-1;;;8207:10:0;;;;;7903:723::o;8176:53::-;8254:5;8239:12;8295:78;8302:9;;8295:78;;8328:8;;;;:::i;:::-;;-1:-1:-1;8351:10:0;;-1:-1:-1;8359:2:0;8351:10;;:::i;:::-;;;8295:78;;;8383:19;8415:6;8405:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8405:17:0;;8383:39;;8433:154;8440:10;;8433:154;;8467:11;8477:1;8467:11;;:::i;:::-;;-1:-1:-1;8536:10:0;8544:2;8536:5;:10;:::i;:::-;8523:24;;:2;:24;:::i;:::-;8510:39;;8493:6;8500;8493:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;8493:56:0;;;;;;;;-1:-1:-1;8564:11:0;8573:2;8564:11;;:::i;:::-;;;8433:154;;;8611:6;7903:723;-1:-1:-1;;;;7903:723:0:o;38939:174::-;39014:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;39014:29:0;-1:-1:-1;;;;;39014:29:0;;;;;;;;:24;;39068:23;39014:24;39068:14;:23::i;:::-;-1:-1:-1;;;;;39059:46:0;;;;;;;;;;;38939:174;;:::o;64042:172::-;64099:7;64123:12;64136:6;64123:20;;;;;;;:::i;:::-;;;:25;64119:87;;64157:12;64170:6;64157:20;;;;;;;:::i;:::-;;;;64042:172;-1:-1:-1;;64042:172:0:o;64119:87::-;-1:-1:-1;64200:6:0;64042:172::o;64119:87::-;64042:172;;;:::o;35904:110::-;35980:26;35990:2;35994:7;35980:26;;;;;;;;;;;;:9;:26::i;35126:436::-;35244:4;34921:16;;;:7;:16;;;;;;-1:-1:-1;;;;;34921:16:0;35261:110;;;;-1:-1:-1;;;35261:110:0;;21401:2:1;35261:110:0;;;21383:21:1;21440:2;21420:18;;;21413:30;21479:34;21459:18;;;21452:62;-1:-1:-1;;;21530:18:1;;;21523:42;21582:19;;35261:110:0;21199:408:1;35261:110:0;35382:13;35398:23;35413:7;35398:14;:23::i;:::-;35382:39;;35451:5;-1:-1:-1;;;;;35440:16:0;:7;-1:-1:-1;;;;;35440:16:0;;:64;;;;35497:7;-1:-1:-1;;;;;35473:31:0;:20;35485:7;35473:11;:20::i;:::-;-1:-1:-1;;;;;35473:31:0;;35440:64;:113;;;-1:-1:-1;;;;;;32107:25:0;;;32083:4;32107:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;35521:32;31961:189;38206:615;38379:4;-1:-1:-1;;;;;38352:31:0;:23;38367:7;38352:14;:23::i;:::-;-1:-1:-1;;;;;38352:31:0;;38330:122;;;;-1:-1:-1;;;38330:122:0;;21814:2:1;38330:122:0;;;21796:21:1;21853:2;21833:18;;;21826:30;21892:34;21872:18;;;21865:62;-1:-1:-1;;;21943:18:1;;;21936:39;21992:19;;38330:122:0;21612:405:1;38330:122:0;-1:-1:-1;;;;;38471:16:0;;38463:65;;;;-1:-1:-1;;;38463:65:0;;22224:2:1;38463:65:0;;;22206:21:1;22263:2;22243:18;;;22236:30;22302:34;22282:18;;;22275:62;-1:-1:-1;;;22353:18:1;;;22346:34;22397:19;;38463:65:0;22022:400:1;38463:65:0;38541:39;38562:4;38568:2;38572:7;38541:20;:39::i;:::-;38645:29;38662:1;38666:7;38645:8;:29::i;:::-;-1:-1:-1;;;;;38687:15:0;;;;;;:9;:15;;;;;:20;;38706:1;;38687:15;:20;;38706:1;;38687:20;:::i;:::-;;;;-1:-1:-1;;;;;;;38718:13:0;;;;;;:9;:13;;;;;:18;;38735:1;;38718:13;:18;;38735:1;;38718:18;:::i;:::-;;;;-1:-1:-1;;38747:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;38747:21:0;-1:-1:-1;;;;;38747:21:0;;;;;;;;;38786:27;;38747:16;;38786:27;;;;;;;38206:615;;;:::o;34167:352::-;34324:28;34334:4;34340:2;34344:7;34324:9;:28::i;:::-;34385:48;34408:4;34414:2;34418:7;34427:5;34385:22;:48::i;:::-;34363:148;;;;-1:-1:-1;;;34363:148:0;;;;;;;:::i;36241:321::-;36371:18;36377:2;36381:7;36371:5;:18::i;:::-;36422:54;36453:1;36457:2;36461:7;36470:5;36422:22;:54::i;:::-;36400:154;;;;-1:-1:-1;;;36400:154:0;;;;;;;:::i;43805:589::-;-1:-1:-1;;;;;44011:18:0;;44007:187;;44046:40;44078:7;45221:10;:17;;45194:24;;;;:15;:24;;;;;:44;;;45249:24;;;;;;;;;;;;45117:164;44046:40;44007:187;;;44116:2;-1:-1:-1;;;;;44108:10:0;:4;-1:-1:-1;;;;;44108:10:0;;44104:90;;44135:47;44168:4;44174:7;44135:32;:47::i;:::-;-1:-1:-1;;;;;44208:16:0;;44204:183;;44241:45;44278:7;44241:36;:45::i;44204:183::-;44314:4;-1:-1:-1;;;;;44308:10:0;:2;-1:-1:-1;;;;;44308:10:0;;44304:83;;44335:40;44363:2;44367:7;44335:27;:40::i;39678:980::-;39833:4;-1:-1:-1;;;;;39854:13:0;;12612:20;12660:8;39850:801;;39907:175;;-1:-1:-1;;;39907:175:0;;-1:-1:-1;;;;;39907:36:0;;;;;:175;;9800:10;;40001:4;;40028:7;;40058:5;;39907:175;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39907:175:0;;;;;;;;-1:-1:-1;;39907:175:0;;;;;;;;;;;;:::i;:::-;;;39886:710;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40265:6;:13;40282:1;40265:18;40261:320;;40308:108;;-1:-1:-1;;;40308:108:0;;;;;;;:::i;40261:320::-;40531:6;40525:13;40516:6;40512:2;40508:15;40501:38;39886:710;-1:-1:-1;;;;;;40146:51:0;-1:-1:-1;;;40146:51:0;;-1:-1:-1;40139:58:0;;39850:801;-1:-1:-1;40635:4:0;39678:980;;;;;;:::o;36898:382::-;-1:-1:-1;;;;;36978:16:0;;36970:61;;;;-1:-1:-1;;;36970:61:0;;23796:2:1;36970:61:0;;;23778:21:1;;;23815:18;;;23808:30;23874:34;23854:18;;;23847:62;23926:18;;36970:61:0;23594:356:1;36970:61:0;34897:4;34921:16;;;:7;:16;;;;;;-1:-1:-1;;;;;34921:16:0;:30;37042:58;;;;-1:-1:-1;;;37042:58:0;;24157:2:1;37042:58:0;;;24139:21:1;24196:2;24176:18;;;24169:30;24235;24215:18;;;24208:58;24283:18;;37042:58:0;23955:352:1;37042:58:0;37113:45;37142:1;37146:2;37150:7;37113:20;:45::i;:::-;-1:-1:-1;;;;;37171:13:0;;;;;;:9;:13;;;;;:18;;37188:1;;37171:13;:18;;37188:1;;37171:18;:::i;:::-;;;;-1:-1:-1;;37200:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;37200:21:0;-1:-1:-1;;;;;37200:21:0;;;;;;;;37239:33;;37200:16;;;37239:33;;37200:16;;37239:33;36898:382;;:::o;45908:1013::-;46199:22;46249:1;46224:22;46241:4;46224:16;:22::i;:::-;:26;;;;:::i;:::-;46261:18;46282:26;;;:17;:26;;;;;;46199:51;;-1:-1:-1;46415:28:0;;;46411:328;;-1:-1:-1;;;;;46482:18:0;;46460:19;46482:18;;;:12;:18;;;;;;;;:34;;;;;;;;;46533:30;;;;;;:44;;;46650:30;;:17;:30;;;;;:43;;;46411:328;-1:-1:-1;46835:26:0;;;;:17;:26;;;;;;;;46828:33;;;-1:-1:-1;;;;;46879:18:0;;;;;:12;:18;;;;;:34;;;;;;;46872:41;45908:1013::o;47216:1079::-;47494:10;:17;47469:22;;47494:21;;47514:1;;47494:21;:::i;:::-;47526:18;47547:24;;;:15;:24;;;;;;47920:10;:26;;47469:46;;-1:-1:-1;47547:24:0;;47469:46;;47920:26;;;;;;:::i;:::-;;;;;;;;;47898:48;;47984:11;47959:10;47970;47959:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;48064:28;;;:15;:28;;;;;;;:41;;;48236:24;;;;;48229:31;48271:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;47287:1008;;;47216:1079;:::o;44695:221::-;44780:14;44797:20;44814:2;44797:16;:20::i;:::-;-1:-1:-1;;;;;44828:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;44873:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;44695:221:0: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;592:118::-;678:5;671:13;664:21;657:5;654:32;644:60;;700:1;697;690:12;715:241;771:6;824:2;812:9;803:7;799:23;795:32;792:52;;;840:1;837;830:12;792:52;879:9;866:23;898:28;920:5;898:28;:::i;961:250::-;1046:1;1056:113;1070:6;1067:1;1064:13;1056:113;;;1146:11;;;1140:18;1127:11;;;1120:39;1092:2;1085:10;1056:113;;;-1:-1:-1;;1203:1:1;1185:16;;1178:27;961:250::o;1216:271::-;1258:3;1296:5;1290:12;1323:6;1318:3;1311:19;1339:76;1408:6;1401:4;1396:3;1392:14;1385:4;1378:5;1374:16;1339:76;:::i;:::-;1469:2;1448:15;-1:-1:-1;;1444:29:1;1435:39;;;;1476:4;1431:50;;1216:271;-1:-1:-1;;1216:271:1:o;1492:220::-;1641:2;1630:9;1623:21;1604:4;1661:45;1702:2;1691:9;1687:18;1679:6;1661:45;:::i;1717:180::-;1776:6;1829:2;1817:9;1808:7;1804:23;1800:32;1797:52;;;1845:1;1842;1835:12;1797:52;-1:-1:-1;1868:23:1;;1717:180;-1:-1:-1;1717:180:1:o;2110:173::-;2178:20;;-1:-1:-1;;;;;2227:31:1;;2217:42;;2207:70;;2273:1;2270;2263:12;2288:254;2356:6;2364;2417:2;2405:9;2396:7;2392:23;2388:32;2385:52;;;2433:1;2430;2423:12;2385:52;2456:29;2475:9;2456:29;:::i;:::-;2446:39;2532:2;2517:18;;;;2504:32;;-1:-1:-1;;;2288:254:1:o;2729:127::-;2790:10;2785:3;2781:20;2778:1;2771:31;2821:4;2818:1;2811:15;2845:4;2842:1;2835:15;2861:275;2932:2;2926:9;2997:2;2978:13;;-1:-1:-1;;2974:27:1;2962:40;;3032:18;3017:34;;3053:22;;;3014:62;3011:88;;;3079:18;;:::i;:::-;3115:2;3108:22;2861:275;;-1:-1:-1;2861:275:1:o;3141:718::-;3195:5;3248:3;3241:4;3233:6;3229:17;3225:27;3215:55;;3266:1;3263;3256:12;3215:55;3302:6;3289:20;3328:4;3351:18;3347:2;3344:26;3341:52;;;3373:18;;:::i;:::-;3419:2;3416:1;3412:10;3442:28;3466:2;3462;3458:11;3442:28;:::i;:::-;3504:15;;;3574;;;3570:24;;;3535:12;;;;3606:15;;;3603:35;;;3634:1;3631;3624:12;3603:35;3670:2;3662:6;3658:15;3647:26;;3682:148;3698:6;3693:3;3690:15;3682:148;;;3764:23;3783:3;3764:23;:::i;:::-;3752:36;;3715:12;;;;3808;;;;3682:148;;;3848:5;3141:718;-1:-1:-1;;;;;;;3141:718:1:o;3864:348::-;3948:6;4001:2;3989:9;3980:7;3976:23;3972:32;3969:52;;;4017:1;4014;4007:12;3969:52;4057:9;4044:23;4090:18;4082:6;4079:30;4076:50;;;4122:1;4119;4112:12;4076:50;4145:61;4198:7;4189:6;4178:9;4174:22;4145:61;:::i;4217:328::-;4294:6;4302;4310;4363:2;4351:9;4342:7;4338:23;4334:32;4331:52;;;4379:1;4376;4369:12;4331:52;4402:29;4421:9;4402:29;:::i;:::-;4392:39;;4450:38;4484:2;4473:9;4469:18;4450:38;:::i;:::-;4440:48;;4535:2;4524:9;4520:18;4507:32;4497:42;;4217:328;;;;;:::o;4550:186::-;4609:6;4662:2;4650:9;4641:7;4637:23;4633:32;4630:52;;;4678:1;4675;4668:12;4630:52;4701:29;4720:9;4701:29;:::i;4741:477::-;4831:6;4839;4892:2;4880:9;4871:7;4867:23;4863:32;4860:52;;;4908:1;4905;4898:12;4860:52;4948:9;4935:23;4981:18;4973:6;4970:30;4967:50;;;5013:1;5010;5003:12;4967:50;5036:61;5089:7;5080:6;5069:9;5065:22;5036:61;:::i;:::-;5026:71;;;5147:2;5136:9;5132:18;5119:32;5160:28;5182:5;5160:28;:::i;:::-;5207:5;5197:15;;;4741:477;;;;;:::o;5463:407::-;5528:5;5562:18;5554:6;5551:30;5548:56;;;5584:18;;:::i;:::-;5622:57;5667:2;5646:15;;-1:-1:-1;;5642:29:1;5673:4;5638:40;5622:57;:::i;:::-;5613:66;;5702:6;5695:5;5688:21;5742:3;5733:6;5728:3;5724:16;5721:25;5718:45;;;5759:1;5756;5749:12;5718:45;5808:6;5803:3;5796:4;5789:5;5785:16;5772:43;5862:1;5855:4;5846:6;5839:5;5835:18;5831:29;5824:40;5463:407;;;;;:::o;5875:451::-;5944:6;5997:2;5985:9;5976:7;5972:23;5968:32;5965:52;;;6013:1;6010;6003:12;5965:52;6053:9;6040:23;6086:18;6078:6;6075:30;6072:50;;;6118:1;6115;6108:12;6072:50;6141:22;;6194:4;6186:13;;6182:27;-1:-1:-1;6172:55:1;;6223:1;6220;6213:12;6172:55;6246:74;6312:7;6307:2;6294:16;6289:2;6285;6281:11;6246:74;:::i;6331:315::-;6396:6;6404;6457:2;6445:9;6436:7;6432:23;6428:32;6425:52;;;6473:1;6470;6463:12;6425:52;6496:29;6515:9;6496:29;:::i;:::-;6486:39;;6575:2;6564:9;6560:18;6547:32;6588:28;6610:5;6588:28;:::i;6651:667::-;6746:6;6754;6762;6770;6823:3;6811:9;6802:7;6798:23;6794:33;6791:53;;;6840:1;6837;6830:12;6791:53;6863:29;6882:9;6863:29;:::i;:::-;6853:39;;6911:38;6945:2;6934:9;6930:18;6911:38;:::i;:::-;6901:48;;6996:2;6985:9;6981:18;6968:32;6958:42;;7051:2;7040:9;7036:18;7023:32;7078:18;7070:6;7067:30;7064:50;;;7110:1;7107;7100:12;7064:50;7133:22;;7186:4;7178:13;;7174:27;-1:-1:-1;7164:55:1;;7215:1;7212;7205:12;7164:55;7238:74;7304:7;7299:2;7286:16;7281:2;7277;7273:11;7238:74;:::i;:::-;7228:84;;;6651:667;;;;;;;:::o;7323:632::-;7494:2;7546:21;;;7616:13;;7519:18;;;7638:22;;;7465:4;;7494:2;7717:15;;;;7691:2;7676:18;;;7465:4;7760:169;7774:6;7771:1;7768:13;7760:169;;;7835:13;;7823:26;;7904:15;;;;7869:12;;;;7796:1;7789:9;7760:169;;;-1:-1:-1;7946:3:1;;7323:632;-1:-1:-1;;;;;;7323:632:1:o;7960:260::-;8028:6;8036;8089:2;8077:9;8068:7;8064:23;8060:32;8057:52;;;8105:1;8102;8095:12;8057:52;8128:29;8147:9;8128:29;:::i;:::-;8118:39;;8176:38;8210:2;8199:9;8195:18;8176:38;:::i;:::-;8166:48;;7960:260;;;;;:::o;8225:356::-;8427:2;8409:21;;;8446:18;;;8439:30;8505:34;8500:2;8485:18;;8478:62;8572:2;8557:18;;8225:356::o;8586:380::-;8665:1;8661:12;;;;8708;;;8729:61;;8783:4;8775:6;8771:17;8761:27;;8729:61;8836:2;8828:6;8825:14;8805:18;8802:38;8799:161;;8882:10;8877:3;8873:20;8870:1;8863:31;8917:4;8914:1;8907:15;8945:4;8942:1;8935:15;8799:161;;8586:380;;;:::o;9789:399::-;9991:2;9973:21;;;10030:2;10010:18;;;10003:30;10069:34;10064:2;10049:18;;10042:62;-1:-1:-1;;;10135:2:1;10120:18;;10113:33;10178:3;10163:19;;9789:399::o;11265:127::-;11326:10;11321:3;11317:20;11314:1;11307:31;11357:4;11354:1;11347:15;11381:4;11378:1;11371:15;11397:127;11458:10;11453:3;11449:20;11446:1;11439:31;11489:4;11486:1;11479:15;11513:4;11510:1;11503:15;11529:135;11568:3;11589:17;;;11586:43;;11609:18;;:::i;:::-;-1:-1:-1;11656:1:1;11645:13;;11529:135::o;12970:545::-;13072:2;13067:3;13064:11;13061:448;;;13108:1;13133:5;13129:2;13122:17;13178:4;13174:2;13164:19;13248:2;13236:10;13232:19;13229:1;13225:27;13219:4;13215:38;13284:4;13272:10;13269:20;13266:47;;;-1:-1:-1;13307:4:1;13266:47;13362:2;13357:3;13353:12;13350:1;13346:20;13340:4;13336:31;13326:41;;13417:82;13435:2;13428:5;13425:13;13417:82;;;13480:17;;;13461:1;13450:13;13417:82;;;13421:3;;;12970:545;;;:::o;13691:1352::-;13817:3;13811:10;13844:18;13836:6;13833:30;13830:56;;;13866:18;;:::i;:::-;13895:97;13985:6;13945:38;13977:4;13971:11;13945:38;:::i;:::-;13939:4;13895:97;:::i;:::-;14047:4;;14111:2;14100:14;;14128:1;14123:663;;;;14830:1;14847:6;14844:89;;;-1:-1:-1;14899:19:1;;;14893:26;14844:89;-1:-1:-1;;13648:1:1;13644:11;;;13640:24;13636:29;13626:40;13672:1;13668:11;;;13623:57;14946:81;;14093:944;;14123:663;12917:1;12910:14;;;12954:4;12941:18;;-1:-1:-1;;14159:20:1;;;14277:236;14291:7;14288:1;14285:14;14277:236;;;14380:19;;;14374:26;14359:42;;14472:27;;;;14440:1;14428:14;;;;14307:19;;14277:236;;;14281:3;14541:6;14532:7;14529:19;14526:201;;;14602:19;;;14596:26;-1:-1:-1;;14685:1:1;14681:14;;;14697:3;14677:24;14673:37;14669:42;14654:58;14639:74;;14526:201;-1:-1:-1;;;;;14773:1:1;14757:14;;;14753:22;14740:36;;-1:-1:-1;13691:1352:1:o;16278:1256::-;16502:3;16540:6;16534:13;16566:4;16579:64;16636:6;16631:3;16626:2;16618:6;16614:15;16579:64;:::i;:::-;16706:13;;16665:16;;;;16728:68;16706:13;16665:16;16763:15;;;16728:68;:::i;:::-;16885:13;;16818:20;;;16858:1;;16923:36;16885:13;16923:36;:::i;:::-;16978:1;16995:18;;;17022:141;;;;17177:1;17172:337;;;;16988:521;;17022:141;-1:-1:-1;;17057:24:1;;17043:39;;17134:16;;17127:24;17113:39;;17102:51;;;-1:-1:-1;17022:141:1;;17172:337;17203:6;17200:1;17193:17;17251:2;17248:1;17238:16;17276:1;17290:169;17304:8;17301:1;17298:15;17290:169;;;17386:14;;17371:13;;;17364:37;17429:16;;;;17321:10;;17290:169;;;17294:3;;17490:8;17483:5;17479:20;17472:27;;16988:521;-1:-1:-1;17525:3:1;;16278:1256;-1:-1:-1;;;;;;;;;;16278:1256:1:o;18255:245::-;18322:6;18375:2;18363:9;18354:7;18350:23;18346:32;18343:52;;;18391:1;18388;18381:12;18343:52;18423:9;18417:16;18442:28;18464:5;18442:28;:::i;19332:127::-;19393:10;19388:3;19384:20;19381:1;19374:31;19424:4;19421:1;19414:15;19448:4;19445:1;19438:15;19464:112;19496:1;19522;19512:35;;19527:18;;:::i;:::-;-1:-1:-1;19561:9:1;;19464:112::o;19581:125::-;19646:9;;;19667:10;;;19664:36;;;19680:18;;:::i;19711:136::-;19750:3;19778:5;19768:39;;19787:18;;:::i;:::-;-1:-1:-1;;;19823:18:1;;19711:136::o;19852:413::-;20054:2;20036:21;;;20093:2;20073:18;;;20066:30;20132:34;20127:2;20112:18;;20105:62;-1:-1:-1;;;20198:2:1;20183:18;;20176:47;20255:3;20240:19;;19852:413::o;20624:120::-;20664:1;20690;20680:35;;20695:18;;:::i;:::-;-1:-1:-1;20729:9:1;;20624:120::o;20749:128::-;20816:9;;;20837:11;;;20834:37;;;20851:18;;:::i;22427:414::-;22629:2;22611:21;;;22668:2;22648:18;;;22641:30;22707:34;22702:2;22687:18;;22680:62;-1:-1:-1;;;22773:2:1;22758:18;;22751:48;22831:3;22816:19;;22427:414::o;22846:489::-;-1:-1:-1;;;;;23115:15:1;;;23097:34;;23167:15;;23162:2;23147:18;;23140:43;23214:2;23199:18;;23192:34;;;23262:3;23257:2;23242:18;;23235:31;;;23040:4;;23283:46;;23309:19;;23301:6;23283:46;:::i;:::-;23275:54;22846:489;-1:-1:-1;;;;;;22846:489:1:o;23340:249::-;23409:6;23462:2;23450:9;23441:7;23437:23;23433:32;23430:52;;;23478:1;23475;23468:12;23430:52;23510:9;23504:16;23529:30;23553:5;23529:30;:::i;24312:127::-;24373:10;24368:3;24364:20;24361:1;24354:31;24404:4;24401:1;24394:15;24428:4;24425:1;24418:15

Swarm Source

ipfs://95846504b3a99cbc5eca2bd36fa8138b9a3be949ddeb5bb7f96ac3d96d0ba730

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