Token FEXRA

Overview ERC-721

Total Supply:
3 FEXRA

Holders:
2 addresses

Profile Summary

 
Contract:
0x5910544d186e7055ee7c02cc04a3f332a317a07c0x5910544d186E7055ee7c02cc04a3f332a317A07C

Balance
0 FEXRA
0x0000000000000000000000000000000000000000
Loading
[ Download CSV Export  ] 
Loading
Loading

Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
FinancialNFT

Compiler Version
v0.8.10+commit.fc410830

Optimization Enabled:
Yes with 999999 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-01-09
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

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

// File @openzeppelin/contracts/token/ERC20/IERC20.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

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

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

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

        return account.code.length > 0;
    }

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

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

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

// File @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transfer.selector, to, value)
        );
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.transferFrom.selector, from, to, value)
        );
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(
                token.approve.selector,
                spender,
                newAllowance
            )
        );
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(
                oldAllowance >= value,
                "SafeERC20: decreased allowance below zero"
            );
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(
                token,
                abi.encodeWithSelector(
                    token.approve.selector,
                    spender,
                    newAllowance
                )
            );
        }
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(
            data,
            "SafeERC20: low-level call failed"
        );
        if (returndata.length > 0) {
            // Return data is optional
            require(
                abi.decode(returndata, (bool)),
                "SafeERC20: ERC20 operation did not succeed"
            );
        }
    }
}

// File @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// File @openzeppelin/contracts/utils/introspection/IERC165.sol

// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

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

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

// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

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

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

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

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

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

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

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

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

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

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

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

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

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

// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

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

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

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

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

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

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

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

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

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

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

/**
 * @dev String operations.
 */
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);
    }
}

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

// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override
        returns (bool)
    {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

// OpenZeppelin Contracts v4.4.1 (token/ERC721/ERC721.sol)

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner)
        public
        view
        virtual
        override
        returns (uint256)
    {
        require(
            owner != address(0),
            "ERC721: 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
    {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721: 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);

        _afterTokenTransfer(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);

        _afterTokenTransfer(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 from incorrect owner"
        );
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(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 Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev 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 {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// File @openzeppelin/contracts/interfaces/IERC165.sol

// OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol)

// File @openzeppelin/contracts/interfaces/IERC2981.sol

// OpenZeppelin Contracts v4.4.1 (interfaces/IERC2981.sol)

/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be payed in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}

// File @openzeppelin/contracts/token/common/ERC2981.sol

// OpenZeppelin Contracts v4.4.0 (token/common/ERC2981.sol)

/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
        external
        view
        override
        returns (address, uint256)
    {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) /
            _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator)
        internal
        virtual
    {
        require(
            feeNumerator <= _feeDenominator(),
            "ERC2981: royalty fee will exceed salePrice"
        );
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `tokenId` must be already minted.
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(
            feeNumerator <= _feeDenominator(),
            "ERC2981: royalty fee will exceed salePrice"
        );
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}

// File @openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol

// OpenZeppelin Contracts v4.4.0 (token/ERC721/extensions/ERC721Royalty.sol)

/**
 * @dev Extension of ERC721 with the ERC2981 NFT Royalty Standard, a standardized way to retrieve royalty payment
 * information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC721Royalty is ERC2981, ERC721 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721, ERC2981)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {ERC721-_burn}. This override additionally clears the royalty information for the token.
     */
    function _burn(uint256 tokenId) internal virtual override {
        super._burn(tokenId);
        _resetTokenRoyalty(tokenId);
    }
}

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

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Enumerable.sol)

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

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

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

// File @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol

// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

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

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

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

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

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

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

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

    /**
     * @dev 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();
    }
}

// File @openzeppelin/contracts/access/IOwnable.sol

// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)

interface IOwnable {
    function owner() external view returns (address);

    function pushOwnership(address newOwner) external;

    function pullOwnership() external;

    function renounceOwnership() external;

    function transferOwnership(address newOwner) external;
}

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

// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

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

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

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

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual override 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 Sets up a push of the ownership of the contract to the specified
     * address which must subsequently pull the ownership to accept it.
     */
    function pushOwnership(address newOwner) public virtual override onlyOwner {
        require(
            newOwner != address(0),
            "Ownable: new owner is the zero address"
        );
        emit OwnershipPushed(_owner, newOwner);
        _newOwner = newOwner;
    }

    /**
     * @dev Accepts the push of ownership of the contract. Must be called by
     * the new owner.
     */
    function pullOwnership() public virtual override {
        require(msg.sender == _newOwner, "Ownable: must be new owner to pull");
        emit OwnershipPulled(_owner, _newOwner);
        _owner = _newOwner;
    }

    /**
     * @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 override onlyOwner {
        _transferOwnership(address(0));
    }

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

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

// File @openzeppelin/contracts/utils/Counters.sol

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

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

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

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

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

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

// File contracts/ERC721.sol

contract FinancialNFT is ERC721Enumerable, ERC721Royalty, Ownable {
    using Counters for Counters.Counter;
    using Strings for uint256;
    using SafeERC20 for IERC20;

    Counters.Counter private _tokenIds;

    event Mint(
        address indexed owner,
        address indexed asset,
        uint256 amount,
        uint256 issue,
        uint256 term,
        uint256 indexed tokenId
    );
    event Burn(uint256 indexed tokenId);

    string private baseURI_;

    address public URIHelper;

    modifier onlyHelper() {
        require(URIHelper == _msgSender(), "Helper: caller is not the helper");
        _;
    }

    struct CertificateDetail {
        address asset;
        uint256 amount;
        uint256 issue;
        uint256 term;
    }

    mapping(uint256 => CertificateDetail) private _certificates;

    mapping(uint256 => string) private _URIs;

    constructor(string memory name, string memory symbol)
        ERC721(name, symbol)
    {}

    /**
     * @dev makes sure that we call the hook properly
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override(ERC721, ERC721Enumerable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Burns the provided token
     *
     * Requirements:
     *
     * - tokenId must be owned by caller
     * - must be contract owner
     * - NFT must be matured
     */
    function burn(uint256 tokenId) public onlyOwner {
        _burn(tokenId);
    }

    /**
     * @dev internal _burn override
     */
    function _burn(uint256 tokenId) internal override(ERC721, ERC721Royalty) {
        require(
            _isApprovedOrOwner(_msgSender(), tokenId),
            "ERC721Burnable: caller is not owner nor approved"
        );

        require(_exists(tokenId), "ERC721Burnable: burn of nonexistent token");

        (, , , , , bool mature) = details(tokenId);

        require(mature, "ERC721Burnable: token cannot be burned until mature");

        delete _certificates[tokenId];

        delete _URIs[tokenId];

        ERC721._burn(tokenId);

        _resetTokenRoyalty(tokenId);

        emit Burn(tokenId);
    }

    /**
     * @dev Retrieves the certificate details for the given token
     *
     * Requirements:
     *
     * - tokenId must exist
     */
    function details(uint256 tokenId)
        public
        view
        returns (
            address asset,
            uint256 amount,
            uint8 decimals,
            uint256 issue,
            uint256 term,
            bool mature
        )
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: details query for nonexistent token"
        );

        CertificateDetail memory detail = _certificates[tokenId];

        asset = detail.asset;

        amount = detail.amount;

        decimals = IERC20Metadata(asset).decimals();

        issue = detail.issue;

        term = detail.term;

        mature = block.timestamp >= (issue + term);
    }

    /**
     * @dev Mints a new token with the given details
     *
     * Requirements:
     *
     * - Must be contract owner
     * - Term must be greater than 900 seconds
     */
    function mint(
        address owner,
        address asset,
        uint256 amount,
        uint256 term
    ) public onlyOwner returns (uint256) {
        require(term >= 900, "ERC721: mint term must be greater than 900");

        _tokenIds.increment();

        uint256 newTokenId = _tokenIds.current();

        _certificates[newTokenId] = CertificateDetail({
            asset: asset,
            amount: amount,
            issue: block.timestamp,
            term: term
        });

        _mint(owner, newTokenId);

        emit Mint(owner, asset, amount, block.timestamp, term, newTokenId);

        return newTokenId;
    }

    /**
     * @dev Changes the Base (shared) URI for tokens
     *
     * Requirements:
     *
     * - Must be contract owner
     */
    function setBaseURI(string memory _baseURI) public onlyOwner {
        baseURI_ = _baseURI;
    }

    /**
     * @dev Sets the Default Royalty amount for token sales
     *
     * Requirements:
     *
     * - Must be contract owner
     */
    function setDefaultRoyalty(address receiver, uint96 feeNumerator)
        public
        onlyOwner
    {
        _setDefaultRoyalty(receiver, feeNumerator);
    }

    /**
     * @dev Sets the token's CID
     *
     * Requirements:
     *
     * - Must be contract owner or URI helper
     */
    function setTokenCID(uint256 tokenId, string memory CID) public {
        require(
            _msgSender() == URIHelper || _msgSender() == owner(),
            "ERC721Metadata: must be owner or helper"
        );
        require(
            _exists(tokenId),
            "ERC721Metadata: CID set for nonexistent token"
        );

        _URIs[tokenId] = CID;
    }

    /**
     * @dev sets the URI helper address that is permitted to update token URIs
     *
     * Requirements:
     *
     * - must be contract owner
     */
    function setURIHelper(address _helper) public onlyOwner {
        URIHelper = _helper;
    }

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

    /**
     * @dev Retrieves the token URI for the informational schema
     *
     * Generally speaking, as all of the pertinent data is stored
     * on-chain in the contract, the URI can be used to attach
     * additional metadata to the ERC721 including image, video, etc.
     *
     * Requirements:
     *
     * - tokenId must exist
     *
     */
    function tokenURI(uint256 tokenId)
        public
        view
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

        string memory CID = _URIs[tokenId];

        return
            bytes(CID).length > 0
                ? string(abi.encodePacked("ipfs://", CID))
                : string(abi.encodePacked(baseURI_, tokenId.toString()));
    }

    /**
     * @dev allow for withdrawing native currency sent to the contract
     *
     * Requirements:
     *
     * - Must be contract owner
     */
    function withdraw() public payable onlyOwner {
        (bool success, ) = payable(msg.sender).call{
            value: address(this).balance
        }("");
        require(success);
    }

    /**
     * @dev allow for withdrawing specific tokens send to the contract
     *
     * Requirements:
     *
     * - Must be contract owner
     */
    function withdrawERC20(address _token) public onlyOwner {
        IERC20 token = IERC20(_token);

        SafeERC20.safeTransfer(token, owner(), token.balanceOf(address(this)));
    }

    /**
     * @dev catches native payments if users send such here
     */
    receive() external payable {}
}

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Burn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"issue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"term","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipPulled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipPushed","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":"URIHelper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"details","outputs":[{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint8","name":"decimals","type":"uint8"},{"internalType":"uint256","name":"issue","type":"uint256"},{"internalType":"uint256","name":"term","type":"uint256"},{"internalType":"bool","name":"mature","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"asset","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"term","type":"uint256"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pullOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"pushOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"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":"_baseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"CID","type":"string"}],"name":"setTokenCID","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_helper","type":"address"}],"name":"setURIHelper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"withdrawERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

60806040523480156200001157600080fd5b50604051620044ee380380620044ee833981016040819052620000349162000251565b8151829082906200004d906002906020850190620000de565b50805162000063906003906020840190620000de565b505050620000806200007a6200008860201b60201c565b6200008c565b5050620002f8565b3390565b600c80546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b828054620000ec90620002bb565b90600052602060002090601f0160209004810192826200011057600085556200015b565b82601f106200012b57805160ff19168380011785556200015b565b828001600101855582156200015b579182015b828111156200015b5782518255916020019190600101906200013e565b50620001699291506200016d565b5090565b5b808211156200016957600081556001016200016e565b634e487b7160e01b600052604160045260246000fd5b600082601f830112620001ac57600080fd5b81516001600160401b0380821115620001c957620001c962000184565b604051601f8301601f19908116603f01168101908282118183101715620001f457620001f462000184565b816040528381526020925086838588010111156200021157600080fd5b600091505b8382101562000235578582018301518183018401529082019062000216565b83821115620002475760008385830101525b9695505050505050565b600080604083850312156200026557600080fd5b82516001600160401b03808211156200027d57600080fd5b6200028b868387016200019a565b93506020850151915080821115620002a257600080fd5b50620002b1858286016200019a565b9150509250929050565b600181811c90821680620002d057607f821691505b60208210811415620002f257634e487b7160e01b600052602260045260246000fd5b50919050565b6141e680620003086000396000f3fe6080604052600436106101e75760003560e01c806370a0823111610102578063af67ca9d11610095578063d39ce77c11610064578063d39ce77c14610609578063e985e9c514610629578063f2fde38b1461067f578063f4f3b2001461069f57600080fd5b8063af67ca9d1461057c578063b3f1c93d146105a9578063b88d4fde146105c9578063c87b56dd146105e957600080fd5b80638da5cb5b116100d15780638da5cb5b146104ae57806395d89b41146104d9578063a005ec7a146104ee578063a22cb4651461055c57600080fd5b806370a0823114610444578063715018a6146104645780637ff28d3a1461047957806386000dbb1461048e57600080fd5b80632a55205a1161017a57806342966c681161014957806342966c68146103c45780634f6ccce7146103e457806355f804b3146104045780636352211e1461042457600080fd5b80632a55205a146103305780632f745c591461037c5780633ccfd60b1461039c57806342842e0e146103a457600080fd5b8063095ea7b3116101b6578063095ea7b3146102b157806318160ddd146102d15780631b322ccb146102f057806323b872dd1461031057600080fd5b806301ffc9a7146101f357806304634d8d1461022857806306fdde031461024a578063081812fc1461026c57600080fd5b366101ee57005b600080fd5b3480156101ff57600080fd5b5061021361020e36600461395c565b6106bf565b60405190151581526020015b60405180910390f35b34801561023457600080fd5b506102486102433660046139a2565b6106ee565b005b34801561025657600080fd5b5061025f610782565b60405161021f9190613a60565b34801561027857600080fd5b5061028c610287366004613a73565b610814565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161021f565b3480156102bd57600080fd5b506102486102cc366004613a8c565b6108ee565b3480156102dd57600080fd5b50600a545b60405190815260200161021f565b3480156102fc57600080fd5b5061024861030b366004613b99565b610a7b565b34801561031c57600080fd5b5061024861032b366004613be0565b610c2a565b34801561033c57600080fd5b5061035061034b366004613c1c565b610ccc565b6040805173ffffffffffffffffffffffffffffffffffffffff909316835260208301919091520161021f565b34801561038857600080fd5b506102e2610397366004613a8c565b610dc3565b610248610e92565b3480156103b057600080fd5b506102486103bf366004613be0565b610f6b565b3480156103d057600080fd5b506102486103df366004613a73565b610f86565b3480156103f057600080fd5b506102e26103ff366004613a73565b611010565b34801561041057600080fd5b5061024861041f366004613c3e565b6110ce565b34801561043057600080fd5b5061028c61043f366004613a73565b611162565b34801561045057600080fd5b506102e261045f366004613c73565b611214565b34801561047057600080fd5b506102486112e2565b34801561048557600080fd5b5061024861136f565b34801561049a57600080fd5b506102486104a9366004613c73565b6114ab565b3480156104ba57600080fd5b50600c5473ffffffffffffffffffffffffffffffffffffffff1661028c565b3480156104e557600080fd5b5061025f611573565b3480156104fa57600080fd5b5061050e610509366004613a73565b611582565b6040805173ffffffffffffffffffffffffffffffffffffffff9097168752602087019590955260ff9093169385019390935260608401526080830191909152151560a082015260c00161021f565b34801561056857600080fd5b50610248610577366004613c9c565b61173c565b34801561058857600080fd5b5060105461028c9073ffffffffffffffffffffffffffffffffffffffff1681565b3480156105b557600080fd5b506102e26105c4366004613cc8565b611747565b3480156105d557600080fd5b506102486105e4366004613d0a565b611977565b3480156105f557600080fd5b5061025f610604366004613a73565b611a1f565b34801561061557600080fd5b50610248610624366004613c73565b611bcd565b34801561063557600080fd5b50610213610644366004613d86565b73ffffffffffffffffffffffffffffffffffffffff918216600090815260076020908152604080832093909416825291909152205460ff1690565b34801561068b57600080fd5b5061024861069a366004613c73565b611d7f565b3480156106ab57600080fd5b506102486106ba366004613c73565b611eac565b60006106ca82611fe4565b806106d957506106d982611feb565b806106e857506106e882611fe4565b92915050565b600c5473ffffffffffffffffffffffffffffffffffffffff163314610774576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064015b60405180910390fd5b61077e8282612041565b5050565b60606002805461079190613db9565b80601f01602080910402602001604051908101604052809291908181526020018280546107bd90613db9565b801561080a5780601f106107df5761010080835404028352916020019161080a565b820191906000526020600020905b8154815290600101906020018083116107ed57829003601f168201915b5050505050905090565b60008181526004602052604081205473ffffffffffffffffffffffffffffffffffffffff166108c5576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602c60248201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860448201527f697374656e7420746f6b656e0000000000000000000000000000000000000000606482015260840161076b565b5060009081526006602052604090205473ffffffffffffffffffffffffffffffffffffffff1690565b60006108f982611162565b90508073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156109b7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e6560448201527f7200000000000000000000000000000000000000000000000000000000000000606482015260840161076b565b3373ffffffffffffffffffffffffffffffffffffffff821614806109e057506109e08133610644565b610a6c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603860248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000606482015260840161076b565b610a7683836121ba565b505050565b60105473ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161480610ace5750600c5473ffffffffffffffffffffffffffffffffffffffff1633145b610b5a576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602760248201527f4552433732314d657461646174613a206d757374206265206f776e6572206f7260448201527f2068656c70657200000000000000000000000000000000000000000000000000606482015260840161076b565b60008281526004602052604090205473ffffffffffffffffffffffffffffffffffffffff16610c0b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602d60248201527f4552433732314d657461646174613a204349442073657420666f72206e6f6e6560448201527f78697374656e7420746f6b656e00000000000000000000000000000000000000606482015260840161076b565b60008281526012602090815260409091208251610a769284019061385f565b610c35335b8261225a565b610cc1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603160248201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60448201527f776e6572206e6f7220617070726f766564000000000000000000000000000000606482015260840161076b565b610a768383836123c6565b600082815260016020908152604080832081518083019092525473ffffffffffffffffffffffffffffffffffffffff8116808352740100000000000000000000000000000000000000009091046bffffffffffffffffffffffff16928201929092528291610d8757506040805180820190915260005473ffffffffffffffffffffffffffffffffffffffff811682527401000000000000000000000000000000000000000090046bffffffffffffffffffffffff1660208201525b602081015160009061271090610dab906bffffffffffffffffffffffff1687613e3c565b610db59190613ea8565b915196919550909350505050565b6000610dce83611214565b8210610e5c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f455243373231456e756d657261626c653a206f776e657220696e646578206f7560448201527f74206f6620626f756e6473000000000000000000000000000000000000000000606482015260840161076b565b5073ffffffffffffffffffffffffffffffffffffffff919091166000908152600860209081526040808320938352929052205490565b600c5473ffffffffffffffffffffffffffffffffffffffff163314610f13576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161076b565b604051600090339047908381818185875af1925050503d8060008114610f55576040519150601f19603f3d011682016040523d82523d6000602084013e610f5a565b606091505b5050905080610f6857600080fd5b50565b610a7683838360405180602001604052806000815250611977565b600c5473ffffffffffffffffffffffffffffffffffffffff163314611007576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161076b565b610f6881612638565b600061101b600a5490565b82106110a9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602c60248201527f455243373231456e756d657261626c653a20676c6f62616c20696e646578206f60448201527f7574206f6620626f756e64730000000000000000000000000000000000000000606482015260840161076b565b600a82815481106110bc576110bc613ebc565b90600052602060002001549050919050565b600c5473ffffffffffffffffffffffffffffffffffffffff16331461114f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161076b565b805161077e90600f90602084019061385f565b60008181526004602052604081205473ffffffffffffffffffffffffffffffffffffffff16806106e8576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602960248201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460448201527f656e7420746f6b656e0000000000000000000000000000000000000000000000606482015260840161076b565b600073ffffffffffffffffffffffffffffffffffffffff82166112b9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f4552433732313a2062616c616e636520717565727920666f7220746865207a6560448201527f726f206164647265737300000000000000000000000000000000000000000000606482015260840161076b565b5073ffffffffffffffffffffffffffffffffffffffff1660009081526005602052604090205490565b600c5473ffffffffffffffffffffffffffffffffffffffff163314611363576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161076b565b61136d60006128bf565b565b600d5473ffffffffffffffffffffffffffffffffffffffff163314611416576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602260248201527f4f776e61626c653a206d757374206265206e6577206f776e657220746f20707560448201527f6c6c000000000000000000000000000000000000000000000000000000000000606482015260840161076b565b600d54600c5460405173ffffffffffffffffffffffffffffffffffffffff92831692909116907faa151555690c956fc3ea32f106bb9f119b5237a061eaa8557cff3e51e3792c8d90600090a3600d54600c80547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff909216919091179055565b600c5473ffffffffffffffffffffffffffffffffffffffff16331461152c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161076b565b601080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b60606003805461079190613db9565b6000806000806000806115b98760009081526004602052604090205473ffffffffffffffffffffffffffffffffffffffff16151590565b611645576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603360248201527f4552433732314d657461646174613a2064657461696c7320717565727920666f60448201527f72206e6f6e6578697374656e7420746f6b656e00000000000000000000000000606482015260840161076b565b6000878152601160209081526040918290208251608081018452815473ffffffffffffffffffffffffffffffffffffffff168082526001830154828501819052600284015483870152600390930154606083015284517f313ce5670000000000000000000000000000000000000000000000000000000081529451909a5091985092899263313ce567926004808401938290030181865afa1580156116ee573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906117129190613eeb565b604082015160608301519196509450925061172d8385613f0e565b42101591505091939550919395565b61077e338383612936565b600c5460009073ffffffffffffffffffffffffffffffffffffffff1633146117cb576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161076b565b61038482101561185d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f4552433732313a206d696e74207465726d206d7573742062652067726561746560448201527f72207468616e2039303000000000000000000000000000000000000000000000606482015260840161076b565b61186b600e80546001019055565b6000611876600e5490565b6040805160808101825273ffffffffffffffffffffffffffffffffffffffff8881168252602080830189815242848601908152606085018a81526000888152601190945295909220935184547fffffffffffffffffffffffff0000000000000000000000000000000000000000169316929092178355905160018301555160028201559051600390910155905061190d8682612a64565b60408051858152426020820152908101849052819073ffffffffffffffffffffffffffffffffffffffff80881691908916907fa55115a2f9ae57c699b769e23a7f54ce6ba307a078c5b5378368e3ec086b69bb9060600160405180910390a490505b949350505050565b611981338361225a565b611a0d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603160248201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60448201527f776e6572206e6f7220617070726f766564000000000000000000000000000000606482015260840161076b565b611a1984848484612c32565b50505050565b60008181526004602052604090205460609073ffffffffffffffffffffffffffffffffffffffff16611ad3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201527f6e6578697374656e7420746f6b656e0000000000000000000000000000000000606482015260840161076b565b60008281526012602052604081208054611aec90613db9565b80601f0160208091040260200160405190810160405280929190818152602001828054611b1890613db9565b8015611b655780601f10611b3a57610100808354040283529160200191611b65565b820191906000526020600020905b815481529060010190602001808311611b4857829003601f168201915b505050505090506000815111611ba557600f611b8084612cd5565b604051602001611b91929190613f42565b604051602081830303815290604052611bc6565b80604051602001611bb69190614020565b6040516020818303038152906040525b9392505050565b600c5473ffffffffffffffffffffffffffffffffffffffff163314611c4e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161076b565b73ffffffffffffffffffffffffffffffffffffffff8116611cf1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f6464726573730000000000000000000000000000000000000000000000000000606482015260840161076b565b600c5460405173ffffffffffffffffffffffffffffffffffffffff8084169216907fea8258f2d9ddb679928cf34b78cf645b7feda9acc828e4dd82d014eaae270eba90600090a3600d80547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b600c5473ffffffffffffffffffffffffffffffffffffffff163314611e00576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161076b565b73ffffffffffffffffffffffffffffffffffffffff8116611ea3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201527f6464726573730000000000000000000000000000000000000000000000000000606482015260840161076b565b610f68816128bf565b600c5473ffffffffffffffffffffffffffffffffffffffff163314611f2d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161076b565b8061077e81611f51600c5473ffffffffffffffffffffffffffffffffffffffff1690565b6040517f70a0823100000000000000000000000000000000000000000000000000000000815230600482015273ffffffffffffffffffffffffffffffffffffffff8516906370a0823190602401602060405180830381865afa158015611fbb573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611fdf9190614065565b612e07565b60006106e8825b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f780e9d630000000000000000000000000000000000000000000000000000000014806106e857506106e882612e94565b6127106bffffffffffffffffffffffff821611156120e1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f455243323938313a20726f79616c7479206665652077696c6c2065786365656460448201527f2073616c65507269636500000000000000000000000000000000000000000000606482015260840161076b565b73ffffffffffffffffffffffffffffffffffffffff821661215e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601960248201527f455243323938313a20696e76616c696420726563656976657200000000000000604482015260640161076b565b6040805180820190915273ffffffffffffffffffffffffffffffffffffffff9092168083526bffffffffffffffffffffffff90911660209092018290527401000000000000000000000000000000000000000090910217600055565b600081815260066020526040902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff8416908117909155819061221482611162565b73ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b60008181526004602052604081205473ffffffffffffffffffffffffffffffffffffffff1661230b576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602c60248201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860448201527f697374656e7420746f6b656e0000000000000000000000000000000000000000606482015260840161076b565b600061231683611162565b90508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff16148061238557508373ffffffffffffffffffffffffffffffffffffffff1661236d84610814565b73ffffffffffffffffffffffffffffffffffffffff16145b8061196f575073ffffffffffffffffffffffffffffffffffffffff80821660009081526007602090815260408083209388168352929052205460ff1661196f565b8273ffffffffffffffffffffffffffffffffffffffff166123e682611162565b73ffffffffffffffffffffffffffffffffffffffff1614612489576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f4552433732313a207472616e736665722066726f6d20696e636f72726563742060448201527f6f776e6572000000000000000000000000000000000000000000000000000000606482015260840161076b565b73ffffffffffffffffffffffffffffffffffffffff821661252b576040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f2061646460448201527f7265737300000000000000000000000000000000000000000000000000000000606482015260840161076b565b612536838383612f36565b6125416000826121ba565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260056020526040812080546001929061257790849061407e565b909155505073ffffffffffffffffffffffffffffffffffffffff821660009081526005602052604081208054600192906125b2908490613f0e565b909155505060008181526004602052604080822080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff86811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b61264133610c2f565b6126cd576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603060248201527f4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656400000000000000000000000000000000606482015260840161076b565b60008181526004602052604090205473ffffffffffffffffffffffffffffffffffffffff1661277e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602960248201527f4552433732314275726e61626c653a206275726e206f66206e6f6e657869737460448201527f656e7420746f6b656e0000000000000000000000000000000000000000000000606482015260840161076b565b600061278982611582565b955050505050508061281d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603360248201527f4552433732314275726e61626c653a20746f6b656e2063616e6e6f742062652060448201527f6275726e656420756e74696c206d617475726500000000000000000000000000606482015260840161076b565b600082815260116020908152604080832080547fffffffffffffffffffffffff0000000000000000000000000000000000000000168155600181018490556002810184905560030183905560129091528120612878916138e3565b61288182612f41565b60008281526001602052604081205560405182907fb90306ad06b2a6ff86ddc9327db583062895ef6540e62dc50add009db5b356eb90600090a25050565b600c805473ffffffffffffffffffffffffffffffffffffffff8381167fffffffffffffffffffffffff0000000000000000000000000000000000000000831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff1614156129cc576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c657200000000000000604482015260640161076b565b73ffffffffffffffffffffffffffffffffffffffff83811660008181526007602090815260408083209487168084529482529182902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b73ffffffffffffffffffffffffffffffffffffffff8216612ae1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f2061646472657373604482015260640161076b565b60008181526004602052604090205473ffffffffffffffffffffffffffffffffffffffff1615612b6d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000604482015260640161076b565b612b7960008383612f36565b73ffffffffffffffffffffffffffffffffffffffff82166000908152600560205260408120805460019290612baf908490613f0e565b909155505060008181526004602052604080822080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b612c3d8484846123c6565b612c498484848461301a565b611a19576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603260248201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560448201527f63656976657220696d706c656d656e7465720000000000000000000000000000606482015260840161076b565b606081612d1557505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b8160005b8115612d3f5780612d2981614095565b9150612d389050600a83613ea8565b9150612d19565b60008167ffffffffffffffff811115612d5a57612d5a613ab6565b6040519080825280601f01601f191660200182016040528015612d84576020820181803683370190505b5090505b841561196f57612d9960018361407e565b9150612da6600a866140ce565b612db1906030613f0e565b60f81b818381518110612dc657612dc6613ebc565b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350612e00600a86613ea8565b9450612d88565b6040805173ffffffffffffffffffffffffffffffffffffffff8416602482015260448082018490528251808303909101815260649091019091526020810180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff167fa9059cbb00000000000000000000000000000000000000000000000000000000179052610a76908490613207565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f80ac58cd000000000000000000000000000000000000000000000000000000001480612f2757507fffffffff0000000000000000000000000000000000000000000000000000000082167f5b5e139f00000000000000000000000000000000000000000000000000000000145b806106e857506106e882613313565b610a768383836133aa565b6000612f4c82611162565b9050612f5a81600084612f36565b612f656000836121ba565b73ffffffffffffffffffffffffffffffffffffffff81166000908152600560205260408120805460019290612f9b90849061407e565b909155505060008281526004602052604080822080547fffffffffffffffffffffffff00000000000000000000000000000000000000001690555183919073ffffffffffffffffffffffffffffffffffffffff8416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908390a45050565b600073ffffffffffffffffffffffffffffffffffffffff84163b156131ff576040517f150b7a0200000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff85169063150b7a02906130919033908990889088906004016140e2565b6020604051808303816000875af19250505080156130ea575060408051601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01682019092526130e79181019061412b565b60015b6131b4573d808015613118576040519150601f19603f3d011682016040523d82523d6000602084013e61311d565b606091505b5080516131ac576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603260248201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560448201527f63656976657220696d706c656d656e7465720000000000000000000000000000606482015260840161076b565b805181602001fd5b7fffffffff00000000000000000000000000000000000000000000000000000000167f150b7a020000000000000000000000000000000000000000000000000000000014905061196f565b50600161196f565b6000613269826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff166134b09092919063ffffffff16565b805190915015610a7657808060200190518101906132879190614148565b610a76576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e60448201527f6f74207375636365656400000000000000000000000000000000000000000000606482015260840161076b565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f2a55205a0000000000000000000000000000000000000000000000000000000014806106e857507f01ffc9a7000000000000000000000000000000000000000000000000000000007fffffffff000000000000000000000000000000000000000000000000000000008316146106e8565b73ffffffffffffffffffffffffffffffffffffffff83166134125761340d81600a80546000838152600b60205260408120829055600182018355919091527fc65a7bb8d6351c1cf70c95a316cc6a92839c986682d98bc35f958f4883f9d2a80155565b61344f565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161461344f5761344f83826134bf565b73ffffffffffffffffffffffffffffffffffffffff821661347357610a7681613576565b8273ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614610a7657610a768282613625565b606061196f8484600085613676565b600060016134cc84611214565b6134d6919061407e565b6000838152600960205260409020549091508082146135365773ffffffffffffffffffffffffffffffffffffffff841660009081526008602090815260408083208584528252808320548484528184208190558352600990915290208190555b50600091825260096020908152604080842084905573ffffffffffffffffffffffffffffffffffffffff9094168352600881528383209183525290812055565b600a546000906135889060019061407e565b6000838152600b6020526040812054600a80549394509092849081106135b0576135b0613ebc565b9060005260206000200154905080600a83815481106135d1576135d1613ebc565b6000918252602080832090910192909255828152600b9091526040808220849055858252812055600a80548061360957613609614165565b6001900381819060005260206000200160009055905550505050565b600061363083611214565b73ffffffffffffffffffffffffffffffffffffffff9093166000908152600860209081526040808320868452825280832085905593825260099052919091209190915550565b606082471015613708576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602660248201527f416464726573733a20696e73756666696369656e742062616c616e636520666f60448201527f722063616c6c0000000000000000000000000000000000000000000000000000606482015260840161076b565b73ffffffffffffffffffffffffffffffffffffffff85163b613786576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604482015260640161076b565b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516137af9190614194565b60006040518083038185875af1925050503d80600081146137ec576040519150601f19603f3d011682016040523d82523d6000602084013e6137f1565b606091505b509150915061380182828661380c565b979650505050505050565b6060831561381b575081611bc6565b82511561382b5782518084602001fd5b816040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161076b9190613a60565b82805461386b90613db9565b90600052602060002090601f01602090048101928261388d57600085556138d3565b82601f106138a657805160ff19168380011785556138d3565b828001600101855582156138d3579182015b828111156138d35782518255916020019190600101906138b8565b506138df929150613919565b5090565b5080546138ef90613db9565b6000825580601f106138ff575050565b601f016020900490600052602060002090810190610f6891905b5b808211156138df576000815560010161391a565b7fffffffff0000000000000000000000000000000000000000000000000000000081168114610f6857600080fd5b60006020828403121561396e57600080fd5b8135611bc68161392e565b803573ffffffffffffffffffffffffffffffffffffffff8116811461399d57600080fd5b919050565b600080604083850312156139b557600080fd5b6139be83613979565b915060208301356bffffffffffffffffffffffff811681146139df57600080fd5b809150509250929050565b60005b83811015613a055781810151838201526020016139ed565b83811115611a195750506000910152565b60008151808452613a2e8160208601602086016139ea565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b602081526000611bc66020830184613a16565b600060208284031215613a8557600080fd5b5035919050565b60008060408385031215613a9f57600080fd5b613aa883613979565b946020939093013593505050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600067ffffffffffffffff80841115613b0057613b00613ab6565b604051601f85017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0908116603f01168101908282118183101715613b4657613b46613ab6565b81604052809350858152868686011115613b5f57600080fd5b858560208301376000602087830101525050509392505050565b600082601f830112613b8a57600080fd5b611bc683833560208501613ae5565b60008060408385031215613bac57600080fd5b82359150602083013567ffffffffffffffff811115613bca57600080fd5b613bd685828601613b79565b9150509250929050565b600080600060608486031215613bf557600080fd5b613bfe84613979565b9250613c0c60208501613979565b9150604084013590509250925092565b60008060408385031215613c2f57600080fd5b50508035926020909101359150565b600060208284031215613c5057600080fd5b813567ffffffffffffffff811115613c6757600080fd5b61196f84828501613b79565b600060208284031215613c8557600080fd5b611bc682613979565b8015158114610f6857600080fd5b60008060408385031215613caf57600080fd5b613cb883613979565b915060208301356139df81613c8e565b60008060008060808587031215613cde57600080fd5b613ce785613979565b9350613cf560208601613979565b93969395505050506040820135916060013590565b60008060008060808587031215613d2057600080fd5b613d2985613979565b9350613d3760208601613979565b925060408501359150606085013567ffffffffffffffff811115613d5a57600080fd5b8501601f81018713613d6b57600080fd5b613d7a87823560208401613ae5565b91505092959194509250565b60008060408385031215613d9957600080fd5b613da283613979565b9150613db060208401613979565b90509250929050565b600181811c90821680613dcd57607f821691505b60208210811415613e07577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0483118215151615613e7457613e74613e0d565b500290565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b600082613eb757613eb7613e79565b500490565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600060208284031215613efd57600080fd5b815160ff81168114611bc657600080fd5b60008219821115613f2157613f21613e0d565b500190565b60008151613f388185602086016139ea565b9290920192915050565b600080845481600182811c915080831680613f5e57607f831692505b6020808410821415613f97577f4e487b710000000000000000000000000000000000000000000000000000000086526022600452602486fd5b818015613fab5760018114613fda57614007565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00861689528489019650614007565b60008b81526020902060005b86811015613fff5781548b820152908501908301613fe6565b505084890196505b5050505050506140178185613f26565b95945050505050565b7f697066733a2f2f000000000000000000000000000000000000000000000000008152600082516140588160078501602087016139ea565b9190910160070192915050565b60006020828403121561407757600080fd5b5051919050565b60008282101561409057614090613e0d565b500390565b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8214156140c7576140c7613e0d565b5060010190565b6000826140dd576140dd613e79565b500690565b600073ffffffffffffffffffffffffffffffffffffffff8087168352808616602084015250836040830152608060608301526141216080830184613a16565b9695505050505050565b60006020828403121561413d57600080fd5b8151611bc68161392e565b60006020828403121561415a57600080fd5b8151611bc681613c8e565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b600082516141a68184602087016139ea565b919091019291505056fea2646970667358221220361214e83bbf7c1f004f4cb6eb8195155f825142b621095dc2d738fe8fff83a964736f6c634300080a0033000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000005464558524100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054645585241000000000000000000000000000000000000000000000000000000

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000004000000000000000000000000000000000000000000000000000000000000000800000000000000000000000000000000000000000000000000000000000000005464558524100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000054645585241000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): FEXRA
Arg [1] : symbol (string): FEXRA

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [3] : 4645585241000000000000000000000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [5] : 4645585241000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

65110:7540:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;70575:374;;;;;;;;;;-1:-1:-1;70575:374:0;;;;;:::i;:::-;;:::i;:::-;;;611:14:1;;604:22;586:41;;574:2;559:18;70575:374:0;;;;;;;;69541:167;;;;;;;;;;-1:-1:-1;69541:167:0;;;;;:::i;:::-;;:::i;:::-;;31345:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;33038:308::-;;;;;;;;;;-1:-1:-1;33038:308:0;;;;;:::i;:::-;;:::i;:::-;;;2403:42:1;2391:55;;;2373:74;;2361:2;2346:18;33038:308:0;2227:226:1;32561:411:0;;;;;;;;;;-1:-1:-1;32561:411:0;;;;;:::i;:::-;;:::i;53937:113::-;;;;;;;;;;-1:-1:-1;54025:10:0;:17;53937:113;;;2863:25:1;;;2851:2;2836:18;53937:113:0;2717:177:1;69853:379:0;;;;;;;;;;-1:-1:-1;69853:379:0;;;;;:::i;:::-;;:::i;33957:376::-;;;;;;;;;;-1:-1:-1;33957:376:0;;;;;:::i;:::-;;:::i;46904:490::-;;;;;;;;;;-1:-1:-1;46904:490:0;;;;;:::i;:::-;;:::i;:::-;;;;5196:42:1;5184:55;;;5166:74;;5271:2;5256:18;;5249:34;;;;5139:18;46904:490:0;4992:297:1;53518:343:0;;;;;;;;;;-1:-1:-1;53518:343:0;;;;;:::i;:::-;;:::i;71983:192::-;;;:::i;34404:185::-;;;;;;;;;;-1:-1:-1;34404:185:0;;;;;:::i;:::-;;:::i;66625:81::-;;;;;;;;;;-1:-1:-1;66625:81:0;;;;;:::i;:::-;;:::i;54127:320::-;;;;;;;;;;-1:-1:-1;54127:320:0;;;;;:::i;:::-;;:::i;69284:99::-;;;;;;;;;;-1:-1:-1;69284:99:0;;;;;:::i;:::-;;:::i;30952:326::-;;;;;;;;;;-1:-1:-1;30952:326:0;;;;;:::i;:::-;;:::i;30595:295::-;;;;;;;;;;-1:-1:-1;30595:295:0;;;;;:::i;:::-;;:::i;62730:112::-;;;;;;;;;;;;;:::i;62162:217::-;;;;;;;;;;;;;:::i;70409:94::-;;;;;;;;;;-1:-1:-1;70409:94:0;;;;;:::i;:::-;;:::i;61265:96::-;;;;;;;;;;-1:-1:-1;61347:6:0;;;;61265:96;;31514:104;;;;;;;;;;;;;:::i;67562:713::-;;;;;;;;;;-1:-1:-1;67562:713:0;;;;;:::i;:::-;;:::i;:::-;;;;6119:42:1;6107:55;;;6089:74;;6194:2;6179:18;;6172:34;;;;6254:4;6242:17;;;6222:18;;;6215:45;;;;6291:2;6276:18;;6269:34;6334:3;6319:19;;6312:35;;;;6391:14;6384:22;6378:3;6363:19;;6356:51;6076:3;6061:19;67562:713:0;5812:601:1;33418:187:0;;;;;;;;;;-1:-1:-1;33418:187:0;;;;;:::i;:::-;;:::i;65605:24::-;;;;;;;;;;-1:-1:-1;65605:24:0;;;;;;;;68474:659;;;;;;;;;;-1:-1:-1;68474:659:0;;;;;:::i;:::-;;:::i;34660:365::-;;;;;;;;;;-1:-1:-1;34660:365:0;;;;;:::i;:::-;;:::i;71326:488::-;;;;;;;;;;-1:-1:-1;71326:488:0;;;;;:::i;:::-;;:::i;61751:284::-;;;;;;;;;;-1:-1:-1;61751:284:0;;;;;:::i;:::-;;:::i;33676:214::-;;;;;;;;;;-1:-1:-1;33676:214:0;;;;;:::i;:::-;33847:25;;;;33818:4;33847:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;33676:214;62997:288;;;;;;;;;;-1:-1:-1;62997:288:0;;;;;:::i;:::-;;:::i;72344:187::-;;;;;;;;;;-1:-1:-1;72344:187:0;;;;;:::i;:::-;;:::i;70575:374::-;70738:4;70780:44;70812:11;70780:31;:44::i;:::-;:108;;;;70841:47;70876:11;70841:34;:47::i;:::-;70780:161;;;;70905:36;70929:11;70905:23;:36::i;:::-;70760:181;70575:374;-1:-1:-1;;70575:374:0:o;69541:167::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;;;;;;;;;69658:42:::1;69677:8;69687:12;69658:18;:42::i;:::-;69541:167:::0;;:::o;31345:100::-;31399:13;31432:5;31425:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31345:100;:::o;33038:308::-;33159:7;36661:16;;;:7;:16;;;;;;:30;:16;33184:110;;;;;;;9205:2:1;33184:110:0;;;9187:21:1;9244:2;9224:18;;;9217:30;9283:34;9263:18;;;9256:62;9354:14;9334:18;;;9327:42;9386:19;;33184:110:0;9003:408:1;33184:110:0;-1:-1:-1;33314:24:0;;;;:15;:24;;;;;;;;;33038:308::o;32561:411::-;32642:13;32658:23;32673:7;32658:14;:23::i;:::-;32642:39;;32706:5;32700:11;;:2;:11;;;;32692:57;;;;;;;9618:2:1;32692:57:0;;;9600:21:1;9657:2;9637:18;;;9630:30;9696:34;9676:18;;;9669:62;9767:3;9747:18;;;9740:31;9788:19;;32692:57:0;9416:397:1;32692:57:0;25521:10;32784:21;;;;;:62;;-1:-1:-1;32809:37:0;32826:5;25521:10;33676:214;:::i;32809:37::-;32762:168;;;;;;;10020:2:1;32762:168:0;;;10002:21:1;10059:2;10039:18;;;10032:30;10098:34;10078:18;;;10071:62;10169:26;10149:18;;;10142:54;10213:19;;32762:168:0;9818:420:1;32762:168:0;32943:21;32952:2;32956:7;32943:8;:21::i;:::-;32631:341;32561:411;;:::o;69853:379::-;69966:9;;;;25521:10;69950:25;;;:52;;;-1:-1:-1;61347:6:0;;;;25521:10;69979:23;69950:52;69928:141;;;;;;;10445:2:1;69928:141:0;;;10427:21:1;10484:2;10464:18;;;10457:30;10523:34;10503:18;;;10496:62;10594:9;10574:18;;;10567:37;10621:19;;69928:141:0;10243:403:1;69928:141:0;36637:4;36661:16;;;:7;:16;;;;;;:30;:16;70080:111;;;;;;;10853:2:1;70080:111:0;;;10835:21:1;10892:2;10872:18;;;10865:30;10931:34;10911:18;;;10904:62;11002:15;10982:18;;;10975:43;11035:19;;70080:111:0;10651:409:1;70080:111:0;70204:14;;;;:5;:14;;;;;;;;:20;;;;;;;;:::i;33957:376::-;34166:41;25521:10;34185:12;34199:7;34166:18;:41::i;:::-;34144:140;;;;;;;11267:2:1;34144:140:0;;;11249:21:1;11306:2;11286:18;;;11279:30;11345:34;11325:18;;;11318:62;11416:19;11396:18;;;11389:47;11453:19;;34144:140:0;11065:413:1;34144:140:0;34297:28;34307:4;34313:2;34317:7;34297:9;:28::i;46904:490::-;47031:7;47094:27;;;:17;:27;;;;;;;;47065:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;47031:7;;47134:92;;-1:-1:-1;47185:29:0;;;;;;;;;-1:-1:-1;47185:29:0;;;;;;;;;;;;;;;47134:92;47276:23;;;;47238:21;;47760:5;;47263:36;;47262:71;47263:36;:10;:36;:::i;:::-;47262:71;;;;:::i;:::-;47354:16;;;;;-1:-1:-1;46904:490:0;;-1:-1:-1;;;;46904:490:0:o;53518:343::-;53660:7;53715:23;53732:5;53715:16;:23::i;:::-;53707:5;:31;53685:124;;;;;;;12421:2:1;53685:124:0;;;12403:21:1;12460:2;12440:18;;;12433:30;12499:34;12479:18;;;12472:62;12570:13;12550:18;;;12543:41;12601:19;;53685:124:0;12219:407:1;53685:124:0;-1:-1:-1;53827:19:0;;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;53518:343::o;71983:192::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;72058:82:::1;::::0;72040:12:::1;::::0;72066:10:::1;::::0;72104:21:::1;::::0;72040:12;72058:82;72040:12;72058:82;72104:21;72066:10;72058:82:::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72039:101;;;72159:7;72151:16;;;::::0;::::1;;72028:147;71983:192::o:0;34404:185::-;34542:39;34559:4;34565:2;34569:7;34542:39;;;;;;;;;;;;:16;:39::i;66625:81::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;66684:14:::1;66690:7;66684:5;:14::i;54127:320::-:0;54247:7;54302:30;54025:10;:17;;53937:113;54302:30;54294:5;:38;54272:132;;;;;;;13043:2:1;54272:132:0;;;13025:21:1;13082:2;13062:18;;;13055:30;13121:34;13101:18;;;13094:62;13192:14;13172:18;;;13165:42;13224:19;;54272:132:0;12841:408:1;54272:132:0;54422:10;54433:5;54422:17;;;;;;;;:::i;:::-;;;;;;;;;54415:24;;54127:320;;;:::o;69284:99::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;69356:19;;::::1;::::0;:8:::1;::::0;:19:::1;::::0;::::1;::::0;::::1;:::i;30952:326::-:0;31069:7;31110:16;;;:7;:16;;;;;;;;31159:19;31137:110;;;;;;;13645:2:1;31137:110:0;;;13627:21:1;13684:2;13664:18;;;13657:30;13723:34;13703:18;;;13696:62;13794:11;13774:18;;;13767:39;13823:19;;31137:110:0;13443:405:1;30595:295:0;30712:7;30759:19;;;30737:111;;;;;;;14055:2:1;30737:111:0;;;14037:21:1;14094:2;14074:18;;;14067:30;14133:34;14113:18;;;14106:62;14204:12;14184:18;;;14177:40;14234:19;;30737:111:0;13853:406:1;30737:111:0;-1:-1:-1;30866:16:0;;;;;;:9;:16;;;;;;;30595:295::o;62730:112::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;62804:30:::1;62831:1;62804:18;:30::i;:::-;62730:112::o:0;62162:217::-;62244:9;;;;62230:10;:23;62222:70;;;;;;;14466:2:1;62222:70:0;;;14448:21:1;14505:2;14485:18;;;14478:30;14544:34;14524:18;;;14517:62;14615:4;14595:18;;;14588:32;14637:19;;62222:70:0;14264:398:1;62222:70:0;62332:9;;62324:6;;62308:34;;62332:9;;;;;62324:6;;;;62308:34;;62332:9;;62308:34;62362:9;;62353:6;:18;;;;62362:9;;;;62353:18;;;;;;62162:217::o;70409:94::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;70476:9:::1;:19:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;70409:94::o;31514:104::-;31570:13;31603:7;31596:14;;;;;:::i;67562:713::-;67658:13;67686:14;67715;67744:13;67772:12;67799:11;67860:16;67868:7;36637:4;36661:16;;;:7;:16;;;;;;:30;:16;:30;;;36572:127;67860:16;67838:117;;;;;;;14869:2:1;67838:117:0;;;14851:21:1;14908:2;14888:18;;;14881:30;14947:34;14927:18;;;14920:62;15018:21;14998:18;;;14991:49;15057:19;;67838:117:0;14667:415:1;67838:117:0;67968:31;68002:22;;;:13;:22;;;;;;;;;67968:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68116:32;;;;;;;67968:56;;-1:-1:-1;67968:56:0;;-1:-1:-1;67968:56:0;;;68116:30;;:32;;;;;;;;;;67968:56;68116:32;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68169:12;;;;68201:11;;;;68105:43;;-1:-1:-1;68169:12:0;-1:-1:-1;68201:11:0;-1:-1:-1;68254:12:0;68201:11;68169:12;68254;:::i;:::-;68234:15;:33;;68225:42;;67827:448;67562:713;;;;;;;:::o;33418:187::-;33545:52;25521:10;33578:8;33588;33545:18;:52::i;68474:659::-;61347:6;;68617:7;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;68653:3:::1;68645:4;:11;;68637:66;;;::::0;::::1;::::0;;15700:2:1;68637:66:0::1;::::0;::::1;15682:21:1::0;15739:2;15719:18;;;15712:30;15778:34;15758:18;;;15751:62;15849:12;15829:18;;;15822:40;15879:19;;68637:66:0::1;15498:406:1::0;68637:66:0::1;68716:21;:9;64696:19:::0;;64714:1;64696:19;;;64607:127;68716:21:::1;68750:18;68771:19;:9;64577:14:::0;;64485:114;68771:19:::1;68831:148;::::0;;::::1;::::0;::::1;::::0;;::::1;::::0;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;68927:15:::1;68831:148:::0;;;;;;;;;;;;-1:-1:-1;68803:25:0;;;:13:::1;:25:::0;;;;;;;:176;;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;;-1:-1:-1;68803:176:0;::::1;::::0;;::::1;::::0;::::1;::::0;;;::::1;::::0;;::::1;::::0;:25;-1:-1:-1;68992:24:0::1;68998:5:::0;68803:25;68992:5:::1;:24::i;:::-;69034:61;::::0;;16111:25:1;;;69061:15:0::1;16167:2:1::0;16152:18;;16145:34;16195:18;;;16188:34;;;69084:10:0;;69034:61:::1;::::0;;::::1;::::0;;;::::1;::::0;::::1;::::0;16099:2:1;16084:18;69034:61:0::1;;;;;;;69115:10:::0;-1:-1:-1;61565:1:0::1;68474:659:::0;;;;;;:::o;34660:365::-;34849:41;25521:10;34882:7;34849:18;:41::i;:::-;34827:140;;;;;;;11267:2:1;34827:140:0;;;11249:21:1;11306:2;11286:18;;;11279:30;11345:34;11325:18;;;11318:62;11416:19;11396:18;;;11389:47;11453:19;;34827:140:0;11065:413:1;34827:140:0;34978:39;34992:4;34998:2;35002:7;35011:5;34978:13;:39::i;:::-;34660:365;;;;:::o;71326:488::-;36637:4;36661:16;;;:7;:16;;;;;;71427:13;;36661:30;:16;71458:113;;;;;;;16435:2:1;71458:113:0;;;16417:21:1;16474:2;16454:18;;;16447:30;16513:34;16493:18;;;16486:62;16584:17;16564:18;;;16557:45;16619:19;;71458:113:0;16233:411:1;71458:113:0;71584:17;71604:14;;;:5;:14;;;;;71584:34;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71671:1;71657:3;71651:17;:21;:155;;71776:8;71786:18;:7;:16;:18::i;:::-;71759:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;71651:155;;;71727:3;71699:32;;;;;;;;:::i;:::-;;;;;;;;;;;;;71651:155;71631:175;71326:488;-1:-1:-1;;;71326:488:0:o;61751:284::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;61859:22:::1;::::0;::::1;61837:110;;;::::0;::::1;::::0;;18890:2:1;61837:110:0::1;::::0;::::1;18872:21:1::0;18929:2;18909:18;;;18902:30;18968:34;18948:18;;;18941:62;19039:8;19019:18;;;19012:36;19065:19;;61837:110:0::1;18688:402:1::0;61837:110:0::1;61979:6;::::0;61963:33:::1;::::0;::::1;::::0;;::::1;::::0;61979:6:::1;::::0;61963:33:::1;::::0;61979:6:::1;::::0;61963:33:::1;62007:9;:20:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;61751:284::o;62997:288::-;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;63150:22:::1;::::0;::::1;63128:110;;;::::0;::::1;::::0;;18890:2:1;63128:110:0::1;::::0;::::1;18872:21:1::0;18929:2;18909:18;;;18902:30;18968:34;18948:18;;;18941:62;19039:8;19019:18;;;19012:36;19065:19;;63128:110:0::1;18688:402:1::0;63128:110:0::1;63249:28;63268:8;63249:18;:28::i;72344:187::-:0;61347:6;;61494:23;61347:6;25521:10;61494:23;61486:68;;;;;;;8402:2:1;61486:68:0;;;8384:21:1;;;8421:18;;;8414:30;8480:34;8460:18;;;8453:62;8532:18;;61486:68:0;8200:356:1;61486:68:0;72433:6;72453:70:::1;72433:6:::0;72483:7:::1;61347:6:::0;;;;;61265:96;72483:7:::1;72492:30;::::0;;;;72516:4:::1;72492:30;::::0;::::1;2373:74:1::0;72492:15:0::1;::::0;::::1;::::0;::::1;::::0;2346:18:1;;72492:30:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72453:22;:70::i;50603:220::-:0;50750:4;50779:36;50803:11;53134:300;53281:4;53323:50;;;53338:35;53323:50;;:103;;;53390:36;53414:11;53390:23;:36::i;48044:392::-;47760:5;48184:33;;;;;48162:125;;;;;;;19486:2:1;48162:125:0;;;19468:21:1;19525:2;19505:18;;;19498:30;19564:34;19544:18;;;19537:62;19635:12;19615:18;;;19608:40;19665:19;;48162:125:0;19284:406:1;48162:125:0;48306:22;;;48298:60;;;;;;;19897:2:1;48298:60:0;;;19879:21:1;19936:2;19916:18;;;19909:30;19975:27;19955:18;;;19948:55;20020:18;;48298:60:0;19695:349:1;48298:60:0;48393:35;;;;;;;;;;;;;;;;;;;;;;;;;;;48371:57;;;;;-1:-1:-1;48371:57:0;48044:392::o;40859:174::-;40934:24;;;;:15;:24;;;;;:29;;;;;;;;;;;;;:24;;40988:23;40934:24;40988:14;:23::i;:::-;40979:46;;;;;;;;;;;;40859:174;;:::o;36866:452::-;36995:4;36661:16;;;:7;:16;;;;;;:30;:16;37017:110;;;;;;;20251:2:1;37017:110:0;;;20233:21:1;20290:2;20270:18;;;20263:30;20329:34;20309:18;;;20302:62;20400:14;20380:18;;;20373:42;20432:19;;37017:110:0;20049:408:1;37017:110:0;37138:13;37154:23;37169:7;37154:14;:23::i;:::-;37138:39;;37207:5;37196:16;;:7;:16;;;:64;;;;37253:7;37229:31;;:20;37241:7;37229:11;:20::i;:::-;:31;;;37196:64;:113;;;-1:-1:-1;33847:25:0;;;;33818:4;33847:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;37277:32;33676:214;40079:662;40252:4;40225:31;;:23;40240:7;40225:14;:23::i;:::-;:31;;;40203:118;;;;;;;20664:2:1;40203:118:0;;;20646:21:1;20703:2;20683:18;;;20676:30;20742:34;20722:18;;;20715:62;20813:7;20793:18;;;20786:35;20838:19;;40203:118:0;20462:401:1;40203:118:0;40340:16;;;40332:65;;;;;;;21070:2:1;40332:65:0;;;21052:21:1;21109:2;21089:18;;;21082:30;21148:34;21128:18;;;21121:62;21219:6;21199:18;;;21192:34;21243:19;;40332:65:0;20868:400:1;40332:65:0;40410:39;40431:4;40437:2;40441:7;40410:20;:39::i;:::-;40514:29;40531:1;40535:7;40514:8;:29::i;:::-;40556:15;;;;;;;:9;:15;;;;;:20;;40575:1;;40556:15;:20;;40575:1;;40556:20;:::i;:::-;;;;-1:-1:-1;;40587:13:0;;;;;;;:9;:13;;;;;:18;;40604:1;;40587:13;:18;;40604:1;;40587:18;:::i;:::-;;;;-1:-1:-1;;40616:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;;40655:27;;40616:16;;40655:27;;;;;;;32631:341;32561:411;;:::o;66769:633::-;66875:41;25521:10;66894:12;25441:98;66875:41;66853:139;;;;;;;21605:2:1;66853:139:0;;;21587:21:1;21644:2;21624:18;;;21617:30;21683:34;21663:18;;;21656:62;21754:18;21734;;;21727:46;21790:19;;66853:139:0;21403:412:1;66853:139:0;36637:4;36661:16;;;:7;:16;;;;;;:30;:16;67005:70;;;;;;;22022:2:1;67005:70:0;;;22004:21:1;22061:2;22041:18;;;22034:30;22100:34;22080:18;;;22073:62;22171:11;22151:18;;;22144:39;22200:19;;67005:70:0;21820:405:1;67005:70:0;67099:11;67114:16;67122:7;67114;:16::i;:::-;67088:42;;;;;;;67151:6;67143:70;;;;;;;22432:2:1;67143:70:0;;;22414:21:1;22471:2;22451:18;;;22444:30;22510:34;22490:18;;;22483:62;22581:21;22561:18;;;22554:49;22620:19;;67143:70:0;22230:415:1;67143:70:0;67233:22;;;;:13;:22;;;;;;;;67226:29;;;;;;;;;;;;;;;;;;;;;;;67275:5;:14;;;;;67268:21;;;:::i;:::-;67302;67315:7;67302:12;:21::i;:::-;49549:26;;;;:17;:26;;;;;49542:33;67381:13;;67386:7;;67381:13;;;;;66842:560;66769:633;:::o;63445:191::-;63538:6;;;;63555:17;;;;;;;;;;;63588:40;;63538:6;;;63555:17;63538:6;;63588:40;;63519:16;;63588:40;63508:128;63445:191;:::o;41175:315::-;41330:8;41321:17;;:5;:17;;;;41313:55;;;;;;;22852:2:1;41313:55:0;;;22834:21:1;22891:2;22871:18;;;22864:30;22930:27;22910:18;;;22903:55;22975:18;;41313:55:0;22650:349:1;41313:55:0;41379:25;;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;;;;;;;;;;;;41441:41;;586::1;;;41441::0;;559:18:1;41441:41:0;;;;;;;41175:315;;;:::o;38654:439::-;38734:16;;;38726:61;;;;;;;23206:2:1;38726:61:0;;;23188:21:1;;;23225:18;;;23218:30;23284:34;23264:18;;;23257:62;23336:18;;38726:61:0;23004:356:1;38726:61:0;36637:4;36661:16;;;:7;:16;;;;;;:30;:16;:30;38798:58;;;;;;;23567:2:1;38798:58:0;;;23549:21:1;23606:2;23586:18;;;23579:30;23645;23625:18;;;23618:58;23693:18;;38798:58:0;23365:352:1;38798:58:0;38869:45;38898:1;38902:2;38906:7;38869:20;:45::i;:::-;38927:13;;;;;;;:9;:13;;;;;:18;;38944:1;;38927:13;:18;;38944:1;;38927:18;:::i;:::-;;;;-1:-1:-1;;38956:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;38995:33;;38956:16;;;38995:33;;38956:16;;38995:33;69541:167;;:::o;35907:352::-;36064:28;36074:4;36080:2;36084:7;36064:9;:28::i;:::-;36125:48;36148:4;36154:2;36158:7;36167:5;36125:22;:48::i;:::-;36103:148;;;;;;;23924:2:1;36103:148:0;;;23906:21:1;23963:2;23943:18;;;23936:30;24002:34;23982:18;;;23975:62;24073:20;24053:18;;;24046:48;24111:19;;36103:148:0;23722:414:1;25990:723:0;26046:13;26267:10;26263:53;;-1:-1:-1;;26294:10:0;;;;;;;;;;;;;;;;;;25990:723::o;26263:53::-;26341:5;26326:12;26382:78;26389:9;;26382:78;;26415:8;;;;:::i;:::-;;-1:-1:-1;26438:10:0;;-1:-1:-1;26446:2:0;26438:10;;:::i;:::-;;;26382:78;;;26470:19;26502:6;26492:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;26492:17:0;;26470:39;;26520:154;26527:10;;26520:154;;26554:11;26564:1;26554:11;;:::i;:::-;;-1:-1:-1;26623:10:0;26631:2;26623:5;:10;:::i;:::-;26610:24;;:2;:24;:::i;:::-;26597:39;;26580:6;26587;26580:14;;;;;;;;:::i;:::-;;;;:56;;;;;;;;;;-1:-1:-1;26651:11:0;26660:2;26651:11;;:::i;:::-;;;26520:154;;12658:248;12829:58;;;5196:42:1;5184:55;;12829:58:0;;;5166:74:1;5256:18;;;;5249:34;;;12829:58:0;;;;;;;;;;5139:18:1;;;;12829:58:0;;;;;;;;;;12852:23;12829:58;;;12775:123;;12809:5;;12775:19;:123::i;30176:355::-;30323:4;30365:40;;;30380:25;30365:40;;:105;;-1:-1:-1;30422:48:0;;;30437:33;30422:48;30365:105;:158;;;;30487:36;30511:11;30487:23;:36::i;66195:223::-;66365:45;66392:4;66398:2;66402:7;66365:26;:45::i;39322:420::-;39382:13;39398:23;39413:7;39398:14;:23::i;:::-;39382:39;;39434:48;39455:5;39470:1;39474:7;39434:20;:48::i;:::-;39523:29;39540:1;39544:7;39523:8;:29::i;:::-;39565:16;;;;;;;:9;:16;;;;;:21;;39585:1;;39565:16;:21;;39585:1;;39565:21;:::i;:::-;;;;-1:-1:-1;;39604:16:0;;;;:7;:16;;;;;;39597:23;;;;;;39638:36;39612:7;;39604:16;39597:23;39638:36;;;;;39604:16;;39638:36;69541:167;;:::o;42055:980::-;42210:4;42231:13;;;4553:19;:23;42227:801;;42284:175;;;;;:36;;;;;;:175;;25521:10;;42378:4;;42405:7;;42435:5;;42284:175;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42284:175:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;42263:710;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42642:13:0;;42638:320;;42685:108;;;;;23924:2:1;42685:108:0;;;23906:21:1;23963:2;23943:18;;;23936:30;24002:34;23982:18;;;23975:62;24073:20;24053:18;;;24046:48;24111:19;;42685:108:0;23722:414:1;42638:320:0;42908:6;42902:13;42893:6;42889:2;42885:15;42878:38;42263:710;42523:51;;42533:41;42523:51;;-1:-1:-1;42516:58:0;;42227:801;-1:-1:-1;43012:4:0;43005:11;;15625:802;16049:23;16075:106;16117:4;16075:106;;;;;;;;;;;;;;;;;16083:5;16075:27;;;;:106;;;;;:::i;:::-;16196:17;;16049:132;;-1:-1:-1;16196:21:0;16192:228;;16311:10;16300:30;;;;;;;;;;;;:::i;:::-;16274:134;;;;;;;25692:2:1;16274:134:0;;;25674:21:1;25731:2;25711:18;;;25704:30;25770:34;25750:18;;;25743:62;25841:12;25821:18;;;25814:40;25871:19;;16274:134:0;25490:406:1;46558:291:0;46705:4;46747:41;;;46762:26;46747:41;;:94;;-1:-1:-1;28788:25:0;28773:40;;;;46805:36;28614:207;55060:589;55266:18;;;55262:187;;55301:40;55333:7;56476:10;:17;;56449:24;;;;:15;:24;;;;;:44;;;56504:24;;;;;;;;;;;;56372:164;55301:40;55262:187;;;55371:2;55363:10;;:4;:10;;;55359:90;;55390:47;55423:4;55429:7;55390:32;:47::i;:::-;55463:16;;;55459:183;;55496:45;55533:7;55496:36;:45::i;55459:183::-;55569:4;55563:10;;:2;:10;;;55559:83;;55590:40;55618:2;55622:7;55590:27;:40::i;7100:229::-;7237:12;7269:52;7291:6;7299:4;7305:1;7308:12;7269:21;:52::i;57163:1002::-;57443:22;57493:1;57468:22;57485:4;57468:16;:22::i;:::-;:26;;;;:::i;:::-;57505:18;57526:26;;;:17;:26;;;;;;57443:51;;-1:-1:-1;57659:28:0;;;57655:328;;57726:18;;;57704:19;57726:18;;;:12;:18;;;;;;;;:34;;;;;;;;;57777:30;;;;;;:44;;;57894:30;;:17;:30;;;;;:43;;;57655:328;-1:-1:-1;58079:26:0;;;;:17;:26;;;;;;;;58072:33;;;58123:18;;;;;;:12;:18;;;;;:34;;;;;;;58116:41;57163:1002::o;58460:1079::-;58738:10;:17;58713:22;;58738:21;;58758:1;;58738:21;:::i;:::-;58770:18;58791:24;;;:15;:24;;;;;;59164:10;:26;;58713:46;;-1:-1:-1;58791:24:0;;58713:46;;59164:26;;;;;;:::i;:::-;;;;;;;;;59142:48;;59228:11;59203:10;59214;59203:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;59308:28;;;:15;:28;;;;;;;:41;;;59480:24;;;;;59473:31;59515:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;58531:1008;;;58460:1079;:::o;55950:221::-;56035:14;56052:20;56069:2;56052:16;:20::i;:::-;56083:16;;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;56128:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;55950:221:0:o;8316:571::-;8486:12;8558:5;8533:21;:30;;8511:118;;;;;;;26292:2:1;8511:118:0;;;26274:21:1;26331:2;26311:18;;;26304:30;26370:34;26350:18;;;26343:62;26441:8;26421:18;;;26414:36;26467:19;;8511:118:0;26090:402:1;8511:118:0;4553:19;;;;8640:60;;;;;;;26699:2:1;8640:60:0;;;26681:21:1;26738:2;26718:18;;;26711:30;26777:31;26757:18;;;26750:59;26826:18;;8640:60:0;26497:353:1;8640:60:0;8714:12;8728:23;8755:6;:11;;8774:5;8795:4;8755:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8713:97;;;;8828:51;8845:7;8854:10;8866:12;8828:16;:51::i;:::-;8821:58;8316:571;-1:-1:-1;;;;;;;8316:571:0:o;11276:712::-;11426:12;11455:7;11451:530;;;-1:-1:-1;11486:10:0;11479:17;;11451:530;11600:17;;:21;11596:374;;11798:10;11792:17;11859:15;11846:10;11842:2;11838:19;11831:44;11596:374;11941:12;11934:20;;;;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:177:1;99:66;92:5;88:78;81:5;78:89;68:117;;181:1;178;171:12;196:245;254:6;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;362:9;349:23;381:30;405:5;381:30;:::i;638:196::-;706:20;;766:42;755:54;;745:65;;735:93;;824:1;821;814:12;735:93;638:196;;;:::o;839:366::-;906:6;914;967:2;955:9;946:7;942:23;938:32;935:52;;;983:1;980;973:12;935:52;1006:29;1025:9;1006:29;:::i;:::-;996:39;;1085:2;1074:9;1070:18;1057:32;1129:26;1122:5;1118:38;1111:5;1108:49;1098:77;;1171:1;1168;1161:12;1098:77;1194:5;1184:15;;;839:366;;;;;:::o;1210:258::-;1282:1;1292:113;1306:6;1303:1;1300:13;1292:113;;;1382:11;;;1376:18;1363:11;;;1356:39;1328:2;1321:10;1292:113;;;1423:6;1420:1;1417:13;1414:48;;;-1:-1:-1;;1458:1:1;1440:16;;1433:27;1210:258::o;1473:328::-;1526:3;1564:5;1558:12;1591:6;1586:3;1579:19;1607:63;1663:6;1656:4;1651:3;1647:14;1640:4;1633:5;1629:16;1607:63;:::i;:::-;1715:2;1703:15;1720:66;1699:88;1690:98;;;;1790:4;1686:109;;1473:328;-1:-1:-1;;1473:328:1:o;1806:231::-;1955:2;1944:9;1937:21;1918:4;1975:56;2027:2;2016:9;2012:18;2004:6;1975:56;:::i;2042:180::-;2101:6;2154:2;2142:9;2133:7;2129:23;2125:32;2122:52;;;2170:1;2167;2160:12;2122:52;-1:-1:-1;2193:23:1;;2042:180;-1:-1:-1;2042:180:1:o;2458:254::-;2526:6;2534;2587:2;2575:9;2566:7;2562:23;2558:32;2555:52;;;2603:1;2600;2593:12;2555:52;2626:29;2645:9;2626:29;:::i;:::-;2616:39;2702:2;2687:18;;;;2674:32;;-1:-1:-1;;;2458:254:1:o;2899:184::-;2951:77;2948:1;2941:88;3048:4;3045:1;3038:15;3072:4;3069:1;3062:15;3088:691;3153:5;3183:18;3224:2;3216:6;3213:14;3210:40;;;3230:18;;:::i;:::-;3364:2;3358:9;3430:2;3418:15;;3269:66;3414:24;;;3440:2;3410:33;3406:42;3394:55;;;3464:18;;;3484:22;;;3461:46;3458:72;;;3510:18;;:::i;:::-;3550:10;3546:2;3539:22;3579:6;3570:15;;3609:6;3601;3594:22;3649:3;3640:6;3635:3;3631:16;3628:25;3625:45;;;3666:1;3663;3656:12;3625:45;3716:6;3711:3;3704:4;3696:6;3692:17;3679:44;3771:1;3764:4;3755:6;3747;3743:19;3739:30;3732:41;;;;3088:691;;;;;:::o;3784:222::-;3827:5;3880:3;3873:4;3865:6;3861:17;3857:27;3847:55;;3898:1;3895;3888:12;3847:55;3920:80;3996:3;3987:6;3974:20;3967:4;3959:6;3955:17;3920:80;:::i;4011:390::-;4089:6;4097;4150:2;4138:9;4129:7;4125:23;4121:32;4118:52;;;4166:1;4163;4156:12;4118:52;4202:9;4189:23;4179:33;;4263:2;4252:9;4248:18;4235:32;4290:18;4282:6;4279:30;4276:50;;;4322:1;4319;4312:12;4276:50;4345;4387:7;4378:6;4367:9;4363:22;4345:50;:::i;:::-;4335:60;;;4011:390;;;;;:::o;4406:328::-;4483:6;4491;4499;4552:2;4540:9;4531:7;4527:23;4523:32;4520:52;;;4568:1;4565;4558:12;4520:52;4591:29;4610:9;4591:29;:::i;:::-;4581:39;;4639:38;4673:2;4662:9;4658:18;4639:38;:::i;:::-;4629:48;;4724:2;4713:9;4709:18;4696:32;4686:42;;4406:328;;;;;:::o;4739:248::-;4807:6;4815;4868:2;4856:9;4847:7;4843:23;4839:32;4836:52;;;4884:1;4881;4874:12;4836:52;-1:-1:-1;;4907:23:1;;;4977:2;4962:18;;;4949:32;;-1:-1:-1;4739:248:1:o;5294:322::-;5363:6;5416:2;5404:9;5395:7;5391:23;5387:32;5384:52;;;5432:1;5429;5422:12;5384:52;5472:9;5459:23;5505:18;5497:6;5494:30;5491:50;;;5537:1;5534;5527:12;5491:50;5560;5602:7;5593:6;5582:9;5578:22;5560:50;:::i;5621:186::-;5680:6;5733:2;5721:9;5712:7;5708:23;5704:32;5701:52;;;5749:1;5746;5739:12;5701:52;5772:29;5791:9;5772:29;:::i;6418:118::-;6504:5;6497:13;6490:21;6483:5;6480:32;6470:60;;6526:1;6523;6516:12;6541:315;6606:6;6614;6667:2;6655:9;6646:7;6642:23;6638:32;6635:52;;;6683:1;6680;6673:12;6635:52;6706:29;6725:9;6706:29;:::i;:::-;6696:39;;6785:2;6774:9;6770:18;6757:32;6798:28;6820:5;6798:28;:::i;6861:397::-;6947:6;6955;6963;6971;7024:3;7012:9;7003:7;6999:23;6995:33;6992:53;;;7041:1;7038;7031:12;6992:53;7064:29;7083:9;7064:29;:::i;:::-;7054:39;;7112:38;7146:2;7135:9;7131:18;7112:38;:::i;:::-;6861:397;;7102:48;;-1:-1:-1;;;;7197:2:1;7182:18;;7169:32;;7248:2;7233:18;7220:32;;6861:397::o;7263:667::-;7358:6;7366;7374;7382;7435:3;7423:9;7414:7;7410:23;7406:33;7403:53;;;7452:1;7449;7442:12;7403:53;7475:29;7494:9;7475:29;:::i;:::-;7465:39;;7523:38;7557:2;7546:9;7542:18;7523:38;:::i;:::-;7513:48;;7608:2;7597:9;7593:18;7580:32;7570:42;;7663:2;7652:9;7648:18;7635:32;7690:18;7682:6;7679:30;7676:50;;;7722:1;7719;7712:12;7676:50;7745:22;;7798:4;7790:13;;7786:27;-1:-1:-1;7776:55:1;;7827:1;7824;7817:12;7776:55;7850:74;7916:7;7911:2;7898:16;7893:2;7889;7885:11;7850:74;:::i;:::-;7840:84;;;7263:667;;;;;;;:::o;7935:260::-;8003:6;8011;8064:2;8052:9;8043:7;8039:23;8035:32;8032:52;;;8080:1;8077;8070:12;8032:52;8103:29;8122:9;8103:29;:::i;:::-;8093:39;;8151:38;8185:2;8174:9;8170:18;8151:38;:::i;:::-;8141:48;;7935:260;;;;;:::o;8561:437::-;8640:1;8636:12;;;;8683;;;8704:61;;8758:4;8750:6;8746:17;8736:27;;8704:61;8811:2;8803:6;8800:14;8780:18;8777:38;8774:218;;;8848:77;8845:1;8838:88;8949:4;8946:1;8939:15;8977:4;8974:1;8967:15;8774:218;;8561:437;;;:::o;11483:184::-;11535:77;11532:1;11525:88;11632:4;11629:1;11622:15;11656:4;11653:1;11646:15;11672:228;11712:7;11838:1;11770:66;11766:74;11763:1;11760:81;11755:1;11748:9;11741:17;11737:105;11734:131;;;11845:18;;:::i;:::-;-1:-1:-1;11885:9:1;;11672:228::o;11905:184::-;11957:77;11954:1;11947:88;12054:4;12051:1;12044:15;12078:4;12075:1;12068:15;12094:120;12134:1;12160;12150:35;;12165:18;;:::i;:::-;-1:-1:-1;12199:9:1;;12094:120::o;13254:184::-;13306:77;13303:1;13296:88;13403:4;13400:1;13393:15;13427:4;13424:1;13417:15;15087:273;15155:6;15208:2;15196:9;15187:7;15183:23;15179:32;15176:52;;;15224:1;15221;15214:12;15176:52;15256:9;15250:16;15306:4;15299:5;15295:16;15288:5;15285:27;15275:55;;15326:1;15323;15316:12;15365:128;15405:3;15436:1;15432:6;15429:1;15426:13;15423:39;;;15442:18;;:::i;:::-;-1:-1:-1;15478:9:1;;15365:128::o;16775:185::-;16817:3;16855:5;16849:12;16870:52;16915:6;16910:3;16903:4;16896:5;16892:16;16870:52;:::i;:::-;16938:16;;;;;16775:185;-1:-1:-1;;16775:185:1:o;16965:1289::-;17141:3;17170:1;17203:6;17197:13;17233:3;17255:1;17283:9;17279:2;17275:18;17265:28;;17343:2;17332:9;17328:18;17365;17355:61;;17409:4;17401:6;17397:17;17387:27;;17355:61;17435:2;17483;17475:6;17472:14;17452:18;17449:38;17446:222;;;17522:77;17517:3;17510:90;17623:4;17620:1;17613:15;17653:4;17648:3;17641:17;17446:222;17684:18;17711:162;;;;17887:1;17882:320;;;;17677:525;;17711:162;17759:66;17748:9;17744:82;17739:3;17732:95;17856:6;17851:3;17847:16;17840:23;;17711:162;;17882:320;16722:1;16715:14;;;16759:4;16746:18;;17977:1;17991:165;18005:6;18002:1;17999:13;17991:165;;;18083:14;;18070:11;;;18063:35;18126:16;;;;18020:10;;17991:165;;;17995:3;;18185:6;18180:3;18176:16;18169:23;;17677:525;;;;;;;18218:30;18244:3;18236:6;18218:30;:::i;:::-;18211:37;16965:1289;-1:-1:-1;;;;;16965:1289:1:o;18259:424::-;18521:9;18516:3;18509:22;18491:3;18560:6;18554:13;18576:61;18630:6;18626:1;18621:3;18617:11;18610:4;18602:6;18598:17;18576:61;:::i;:::-;18657:16;;;;18675:1;18653:24;;18259:424;-1:-1:-1;;18259:424:1:o;19095:184::-;19165:6;19218:2;19206:9;19197:7;19193:23;19189:32;19186:52;;;19234:1;19231;19224:12;19186:52;-1:-1:-1;19257:16:1;;19095:184;-1:-1:-1;19095:184:1:o;21273:125::-;21313:4;21341:1;21338;21335:8;21332:34;;;21346:18;;:::i;:::-;-1:-1:-1;21383:9:1;;21273:125::o;24141:195::-;24180:3;24211:66;24204:5;24201:77;24198:103;;;24281:18;;:::i;:::-;-1:-1:-1;24328:1:1;24317:13;;24141:195::o;24341:112::-;24373:1;24399;24389:35;;24404:18;;:::i;:::-;-1:-1:-1;24438:9:1;;24341:112::o;24458:523::-;24652:4;24681:42;24762:2;24754:6;24750:15;24739:9;24732:34;24814:2;24806:6;24802:15;24797:2;24786:9;24782:18;24775:43;;24854:6;24849:2;24838:9;24834:18;24827:34;24897:3;24892:2;24881:9;24877:18;24870:31;24918:57;24970:3;24959:9;24955:19;24947:6;24918:57;:::i;:::-;24910:65;24458:523;-1:-1:-1;;;;;;24458:523:1:o;24986:249::-;25055:6;25108:2;25096:9;25087:7;25083:23;25079:32;25076:52;;;25124:1;25121;25114:12;25076:52;25156:9;25150:16;25175:30;25199:5;25175:30;:::i;25240:245::-;25307:6;25360:2;25348:9;25339:7;25335:23;25331:32;25328:52;;;25376:1;25373;25366:12;25328:52;25408:9;25402:16;25427:28;25449:5;25427:28;:::i;25901:184::-;25953:77;25950:1;25943:88;26050:4;26047:1;26040:15;26074:4;26071:1;26064:15;26855:274;26984:3;27022:6;27016:13;27038:53;27084:6;27079:3;27072:4;27064:6;27060:17;27038:53;:::i;:::-;27107:16;;;;;26855:274;-1:-1:-1;;26855:274:1:o

Swarm Source

ipfs://361214e83bbf7c1f004f4cb6eb8195155f825142b621095dc2d738fe8fff83a9
Loading