Token

FloorItAndGTFO (FloorItAndGTFO)

ERC-721

Overview

Max Total Supply

472 FloorItAndGTFO

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x94423a1592fb1e8d56a0f876017a5f40c385be79

Filtered by Token Holder

0x66f90AAe6c25576FB6c07f92646bE2A0328d0121

Balance

5 FloorItAndGTFO

0x66f90aae6c25576fb6c07f92646be2a0328d0121

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

FloorItAndGTFO

Compiler Version

v0.8.18+commit.87f61d96

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-03-17
*/

// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/lib/Constants.sol


pragma solidity ^0.8.13;

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

// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/IOperatorFilterRegistry.sol


pragma solidity ^0.8.13;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/OperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  OperatorFilterer
 * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another
 *         registrant's entries in the OperatorFilterRegistry.
 * @dev    This smart contract is meant to be inherited by token contracts so they can use the following:
 *         - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods.
 *         - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods.
 *         Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

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

    IOperatorFilterRegistry public constant OPERATOR_FILTER_REGISTRY =
        IOperatorFilterRegistry(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS);

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

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

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

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

// File: https://github.com/ProjectOpenSea/operator-filter-registry/blob/main/src/DefaultOperatorFilterer.sol


pragma solidity ^0.8.13;


/**
 * @title  DefaultOperatorFilterer
 * @notice Inherits from OperatorFilterer and automatically subscribes to the default OpenSea subscription.
 * @dev    Please note that if your token contract does not provide an owner with EIP-173, it must provide
 *         administration methods on the contract itself to interact with the registry otherwise the subscription
 *         will be locked to the options set during construction.
 */

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

// File: https://github.com/OpenZeppelin/openzeppelin-contracts/blob/v4.3.3/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/[email protected]/utils/Strings.sol



pragma solidity ^0.8.0;

/**
 * @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/[email protected]/utils/Context.sol



pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/[email protected]/access/Ownable.sol



pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

// File: @openzeppelin/[email protected]/utils/Address.sol



pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

// File: @openzeppelin/[email protected]/token/ERC721/IERC721Receiver.sol



pragma solidity ^0.8.0;

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

// File: @openzeppelin/[email protected]/utils/introspection/IERC165.sol



pragma solidity ^0.8.0;

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

// File: @openzeppelin/[email protected]/utils/introspection/ERC165.sol



pragma solidity ^0.8.0;


/**
 * @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/[email protected]/token/ERC721/IERC721.sol



pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/[email protected]/token/ERC721/extensions/IERC721Enumerable.sol



pragma solidity ^0.8.0;


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

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

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

// File: @openzeppelin/[email protected]/token/ERC721/extensions/IERC721Metadata.sol



pragma solidity ^0.8.0;


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

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

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

// File: @openzeppelin/[email protected]/token/ERC721/ERC721.sol



pragma solidity ^0.8.0;








/**
 * @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 {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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

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

// File: @openzeppelin/[email protected]/token/ERC721/extensions/ERC721Enumerable.sol



pragma solidity ^0.8.0;



/**
 * @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: contracts/FloorItAndGTFO.sol


pragma solidity ^0.8.7;

contract FloorItAndGTFO is Ownable, ERC721, DefaultOperatorFilterer {
    using SafeMath for uint256;

    uint256 public maxPerTransaction = 5; //Max per transaction
    uint256 public supplyLimit = 6969;
    uint256 public freeSupply = 4242;
    bool public publicSaleActive = true;
    uint256 public totalSupply;
    string public baseURI;
    uint256 public tokenPrice = 6900000000000000;

    constructor(
        string memory name,
        string memory symbol,
        string memory baseURIinput
    ) ERC721(name, symbol) {
        baseURI = baseURIinput;
    }

    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    function setBaseURI(string calldata newBaseUri) external onlyOwner {
        baseURI = newBaseUri;
    }

    function togglePublicSaleActive() external onlyOwner {
        publicSaleActive = !publicSaleActive;
    }

    function buy(uint256 _count) public payable {
        require(_count <= maxPerTransaction, "invalid token count");
        require(
            tokenPrice.mul(_count) <= msg.value,
            "Ether value sent is not correct"
        );
        require(publicSaleActive == true, "Sale is Paused.");
        require((totalSupply + _count) <= supplyLimit, "supply reached");

        uint256 newId = totalSupply;

        for (uint256 i = 0; i < _count; i++) {
            newId += 1;
            _safeMint(msg.sender, newId);
        }

        totalSupply = newId;
    }

    function freeMint(uint256 numberOfTokens) public {
        require(totalSupply <= freeSupply, "Reached free supply");
        require(publicSaleActive == true, "Sale is not active");
        require(
            numberOfTokens <= maxPerTransaction,
            "Over max per transaction!"
        );

        uint256 newId = totalSupply;
        for (uint256 i = 0; i < numberOfTokens; i++) {
            newId += 1;
            _safeMint(msg.sender, newId);
        }
        totalSupply = newId;
    }

    function changeFreeMintSupply(uint256 newSupply) public onlyOwner {
        freeSupply = newSupply;
    }

    function changePrice(uint256 newPrice) public onlyOwner {
        tokenPrice = newPrice;
    }

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

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

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

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

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual override(ERC721) {
        super._beforeTokenTransfer(from, to, amount);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"string","name":"baseURIinput","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"OPERATOR_FILTER_REGISTRY","outputs":[{"internalType":"contract IOperatorFilterRegistry","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":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_count","type":"uint256"}],"name":"buy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newSupply","type":"uint256"}],"name":"changeFreeMintSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"changePrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"freeMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"freeSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"maxPerTransaction","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newBaseUri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"supplyLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"togglePublicSaleActive","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"tokenPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e0000000000000000000000000000000000000000000000000000000000000000e466c6f6f724974416e644754464f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e466c6f6f724974416e644754464f000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004468747470733a2f2f697066732e696f2f697066732f516d64594472645635626a6b7448635a63587a4e314467547577317a48436f4471424c317931454a5962563551562f00000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): FloorItAndGTFO
Arg [1] : symbol (string): FloorItAndGTFO
Arg [2] : baseURIinput (string): https://ipfs.io/ipfs/QmdYDrdV5bjktHcZcXzN1DgTuw1zHCoDqBL1y1EJYbV5QV/

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [3] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [4] : 466c6f6f724974416e644754464f000000000000000000000000000000000000
Arg [5] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [6] : 466c6f6f724974416e644754464f000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000044
Arg [8] : 68747470733a2f2f697066732e696f2f697066732f516d64594472645635626a
Arg [9] : 6b7448635a63587a4e314467547577317a48436f4471424c317931454a596256
Arg [10] : 3551562f00000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

61601:3539:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64715:211;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43269:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44828:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44351:411;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62419:108;;;;;;;;;;;;;:::i;:::-;;61897:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61776:33;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64026:205;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;61816:32;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63875:143;;;;;;;;;;;;;:::i;:::-;;7867;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;64239:213;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;61711:36;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;63656:107;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;62305:106;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42963:239;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;61930:21;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42693:208;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22920:94;;;;;;;;;;;;;:::i;:::-;;63131:517;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;61958:44;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;22269:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43438:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45121:295;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;63771:96;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;64460:247;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;61855:35;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43613:334;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;62535:588;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45487:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23169:192;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;64715:211;64853:4;64882:36;64906:11;64882:23;:36::i;:::-;64875:43;;64715:211;;;:::o;43269:100::-;43323:13;43356:5;43349:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43269:100;:::o;44828:221::-;44904:7;44932:16;44940:7;44932;:16::i;:::-;44924:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;45017:15;:24;45033:7;45017:24;;;;;;;;;;;;;;;;;;;;;45010:31;;44828:221;;;:::o;44351:411::-;44432:13;44448:23;44463:7;44448:14;:23::i;:::-;44432:39;;44496:5;44490:11;;:2;:11;;;44482:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;44590:5;44574:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;44599:37;44616:5;44623:12;:10;:12::i;:::-;44599:16;:37::i;:::-;44574:62;44552:168;;;;;;;;;;;;:::i;:::-;;;;;;;;;44733:21;44742:2;44746:7;44733:8;:21::i;:::-;44421:341;44351:411;;:::o;62419:108::-;22500:12;:10;:12::i;:::-;22489:23;;:7;:5;:7::i;:::-;:23;;;22481:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;62503:16:::1;;;;;;;;;;;62502:17;62483:16;;:36;;;;;;;;;;;;;;;;;;62419:108::o:0;61897:26::-;;;;:::o;61776:33::-;;;;:::o;64026:205::-;64169:4;9383:10;9375:18;;:4;:18;;;9371:83;;9410:32;9431:10;9410:20;:32::i;:::-;9371:83;64186:37:::1;64205:4;64211:2;64215:7;64186:18;:37::i;:::-;64026:205:::0;;;;:::o;61816:32::-;;;;:::o;63875:143::-;22500:12;:10;:12::i;:::-;22489:23;;:7;:5;:7::i;:::-;:23;;;22481:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;63923:15:::1;63941:21;63923:39;;63981:10;63973:28;;:37;64002:7;63973:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;63912:106;63875:143::o:0;7867:::-;195:42;7867:143;:::o;64239:213::-;64386:4;9383:10;9375:18;;:4;:18;;;9371:83;;9410:32;9431:10;9410:20;:32::i;:::-;9371:83;64403:41:::1;64426:4;64432:2;64436:7;64403:22;:41::i;:::-;64239:213:::0;;;;:::o;61711:36::-;;;;:::o;63656:107::-;22500:12;:10;:12::i;:::-;22489:23;;:7;:5;:7::i;:::-;:23;;;22481:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;63746:9:::1;63733:10;:22;;;;63656:107:::0;:::o;62305:106::-;22500:12;:10;:12::i;:::-;22489:23;;:7;:5;:7::i;:::-;:23;;;22481:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;62393:10:::1;;62383:7;:20;;;;;;;:::i;:::-;;62305:106:::0;;:::o;42963:239::-;43035:7;43055:13;43071:7;:16;43079:7;43071:16;;;;;;;;;;;;;;;;;;;;;43055:32;;43123:1;43106:19;;:5;:19;;;43098:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;43189:5;43182:12;;;42963:239;;;:::o;61930:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;42693:208::-;42765:7;42810:1;42793:19;;:5;:19;;;42785:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;42877:9;:16;42887:5;42877:16;;;;;;;;;;;;;;;;42870:23;;42693:208;;;:::o;22920:94::-;22500:12;:10;:12::i;:::-;22489:23;;:7;:5;:7::i;:::-;:23;;;22481:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;22985:21:::1;23003:1;22985:9;:21::i;:::-;22920:94::o:0;63131:517::-;63214:10;;63199:11;;:25;;63191:57;;;;;;;;;;;;:::i;:::-;;;;;;;;;63287:4;63267:24;;:16;;;;;;;;;;;:24;;;63259:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;63365:17;;63347:14;:35;;63325:110;;;;;;;;;;;;:::i;:::-;;;;;;;;;63448:13;63464:11;;63448:27;;63491:9;63486:125;63510:14;63506:1;:18;63486:125;;;63555:1;63546:10;;;;;:::i;:::-;;;63571:28;63581:10;63593:5;63571:9;:28::i;:::-;63526:3;;;;;:::i;:::-;;;;63486:125;;;;63635:5;63621:11;:19;;;;63180:468;63131:517;:::o;61958:44::-;;;;:::o;22269:87::-;22315:7;22342:6;;;;;;;;;;;22335:13;;22269:87;:::o;43438:104::-;43494:13;43527:7;43520:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43438:104;:::o;45121:295::-;45236:12;:10;:12::i;:::-;45224:24;;:8;:24;;;45216:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;45336:8;45291:18;:32;45310:12;:10;:12::i;:::-;45291:32;;;;;;;;;;;;;;;:42;45324:8;45291:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;45389:8;45360:48;;45375:12;:10;:12::i;:::-;45360:48;;;45399:8;45360:48;;;;;;:::i;:::-;;;;;;;;45121:295;;:::o;63771:96::-;22500:12;:10;:12::i;:::-;22489:23;;:7;:5;:7::i;:::-;:23;;;22481:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;63851:8:::1;63838:10;:21;;;;63771:96:::0;:::o;64460:247::-;64635:4;9383:10;9375:18;;:4;:18;;;9371:83;;9410:32;9431:10;9410:20;:32::i;:::-;9371:83;64652:47:::1;64675:4;64681:2;64685:7;64694:4;64652:22;:47::i;:::-;64460:247:::0;;;;;:::o;61855:35::-;;;;;;;;;;;;;:::o;43613:334::-;43686:13;43720:16;43728:7;43720;:16::i;:::-;43712:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;43801:21;43825:10;:8;:10::i;:::-;43801:34;;43877:1;43859:7;43853:21;:25;:86;;;;;;;;;;;;;;;;;43905:7;43914:18;:7;:16;:18::i;:::-;43888:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;43853:86;43846:93;;;43613:334;;;:::o;62535:588::-;62608:17;;62598:6;:27;;62590:59;;;;;;;;;;;;:::i;:::-;;;;;;;;;62708:9;62682:22;62697:6;62682:10;;:14;;:22;;;;:::i;:::-;:35;;62660:116;;;;;;;;;;;;:::i;:::-;;;;;;;;;62815:4;62795:24;;:16;;;;;;;;;;;:24;;;62787:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;62884:11;;62873:6;62859:11;;:20;;;;:::i;:::-;62858:37;;62850:64;;;;;;;;;;;;:::i;:::-;;;;;;;;;62927:13;62943:11;;62927:27;;62972:9;62967:117;62991:6;62987:1;:10;62967:117;;;63028:1;63019:10;;;;;:::i;:::-;;;63044:28;63054:10;63066:5;63044:9;:28::i;:::-;62999:3;;;;;:::i;:::-;;;;62967:117;;;;63110:5;63096:11;:19;;;;62579:544;62535:588;:::o;45487:164::-;45584:4;45608:18;:25;45627:5;45608:25;;;;;;;;;;;;;;;:35;45634:8;45608:35;;;;;;;;;;;;;;;;;;;;;;;;;45601:42;;45487:164;;;;:::o;23169:192::-;22500:12;:10;:12::i;:::-;22489:23;;:7;:5;:7::i;:::-;:23;;;22481:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;23278:1:::1;23258:22;;:8;:22;;::::0;23250:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;23334:19;23344:8;23334:9;:19::i;:::-;23169:192:::0;:::o;42324:305::-;42426:4;42478:25;42463:40;;;:11;:40;;;;:105;;;;42535:33;42520:48;;;:11;:48;;;;42463:105;:158;;;;42585:36;42609:11;42585:23;:36::i;:::-;42463:158;42443:178;;42324:305;;;:::o;48222:127::-;48287:4;48339:1;48311:30;;:7;:16;48319:7;48311:16;;;;;;;;;;;;;;;;;;;;;:30;;;;48304:37;;48222:127;;;:::o;21051:98::-;21104:7;21131:10;21124:17;;21051:98;:::o;52204:174::-;52306:2;52279:15;:24;52295:7;52279:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;52362:7;52358:2;52324:46;;52333:23;52348:7;52333:14;:23::i;:::-;52324:46;;;;;;;;;;;;52204:174;;:::o;9792:647::-;10031:1;195:42;9983:45;;;:49;9979:453;;;195:42;10282;;;10333:4;10340:8;10282:67;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10277:144;;10396:8;10377:28;;;;;;;;;;;:::i;:::-;;;;;;;;10277:144;9979:453;9792:647;:::o;45718:339::-;45913:41;45932:12;:10;:12::i;:::-;45946:7;45913:18;:41::i;:::-;45905:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;46021:28;46031:4;46037:2;46041:7;46021:9;:28::i;:::-;45718:339;;;:::o;46128:185::-;46266:39;46283:4;46289:2;46293:7;46266:39;;;;;;;;;;;;:16;:39::i;:::-;46128:185;;;:::o;23369:173::-;23425:16;23444:6;;;;;;;;;;;23425:25;;23470:8;23461:6;;:17;;;;;;;;;;;;;;;;;;23525:8;23494:40;;23515:8;23494:40;;;;;;;;;;;;23414:128;23369:173;:::o;49206:110::-;49282:26;49292:2;49296:7;49282:26;;;;;;;;;;;;:9;:26::i;:::-;49206:110;;:::o;46384:328::-;46559:41;46578:12;:10;:12::i;:::-;46592:7;46559:18;:41::i;:::-;46551:103;;;;;;;;;;;;:::i;:::-;;;;;;;;;46665:39;46679:4;46685:2;46689:7;46698:5;46665:13;:39::i;:::-;46384:328;;;;:::o;62197:100::-;62249:13;62282:7;62275:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;62197:100;:::o;18661:723::-;18717:13;18947:1;18938:5;:10;18934:53;;18965:10;;;;;;;;;;;;;;;;;;;;;18934:53;18997:12;19012:5;18997:20;;19028:14;19053:78;19068:1;19060:4;:9;19053:78;;19086:8;;;;;:::i;:::-;;;;19117:2;19109:10;;;;;:::i;:::-;;;19053:78;;;19141:19;19173:6;19163:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19141:39;;19191:154;19207:1;19198:5;:10;19191:154;;19235:1;19225:11;;;;;:::i;:::-;;;19302:2;19294:5;:10;;;;:::i;:::-;19281:2;:24;;;;:::i;:::-;19268:39;;19251:6;19258;19251:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;19331:2;19322:11;;;;;:::i;:::-;;;19191:154;;;19369:6;19355:21;;;;;18661:723;;;;:::o;14917:98::-;14975:7;15006:1;15002;:5;;;;:::i;:::-;14995:12;;14917:98;;;;:::o;34279:157::-;34364:4;34403:25;34388:40;;;:11;:40;;;;34381:47;;34279:157;;;:::o;48516:348::-;48609:4;48634:16;48642:7;48634;:16::i;:::-;48626:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;48710:13;48726:23;48741:7;48726:14;:23::i;:::-;48710:39;;48779:5;48768:16;;:7;:16;;;:51;;;;48812:7;48788:31;;:20;48800:7;48788:11;:20::i;:::-;:31;;;48768:51;:87;;;;48823:32;48840:5;48847:7;48823:16;:32::i;:::-;48768:87;48760:96;;;48516:348;;;;:::o;51508:578::-;51667:4;51640:31;;:23;51655:7;51640:14;:23::i;:::-;:31;;;51632:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;51750:1;51736:16;;:2;:16;;;51728:65;;;;;;;;;;;;:::i;:::-;;;;;;;;;51806:39;51827:4;51833:2;51837:7;51806:20;:39::i;:::-;51910:29;51927:1;51931:7;51910:8;:29::i;:::-;51971:1;51952:9;:15;51962:4;51952:15;;;;;;;;;;;;;;;;:20;;;;;;;:::i;:::-;;;;;;;;52000:1;51983:9;:13;51993:2;51983:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;52031:2;52012:7;:16;52020:7;52012:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;52070:7;52066:2;52051:27;;52060:4;52051:27;;;;;;;;;;;;51508:578;;;:::o;49543:321::-;49673:18;49679:2;49683:7;49673:5;:18::i;:::-;49724:54;49755:1;49759:2;49763:7;49772:5;49724:22;:54::i;:::-;49702:154;;;;;;;;;;;;:::i;:::-;;;;;;;;;49543:321;;;:::o;47594:315::-;47751:28;47761:4;47767:2;47771:7;47751:9;:28::i;:::-;47798:48;47821:4;47827:2;47831:7;47840:5;47798:22;:48::i;:::-;47790:111;;;;;;;;;;;;:::i;:::-;;;;;;;;;47594:315;;;;:::o;64934:203::-;65085:44;65112:4;65118:2;65122:6;65085:26;:44::i;:::-;64934:203;;;:::o;50200:382::-;50294:1;50280:16;;:2;:16;;;50272:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;50353:16;50361:7;50353;:16::i;:::-;50352:17;50344:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;50415:45;50444:1;50448:2;50452:7;50415:20;:45::i;:::-;50490:1;50473:9;:13;50483:2;50473:13;;;;;;;;;;;;;;;;:18;;;;;;;:::i;:::-;;;;;;;;50521:2;50502:7;:16;50510:7;50502:16;;;;;;;;;;;;:21;;;;;;;;;;;;;;;;;;50566:7;50562:2;50541:33;;50558:1;50541:33;;;;;;;;;;;;50200:382;;:::o;52943:799::-;53098:4;53119:15;:2;:13;;;:15::i;:::-;53115:620;;;53171:2;53155:36;;;53192:12;:10;:12::i;:::-;53206:4;53212:7;53221:5;53155:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;53151:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53414:1;53397:6;:13;:18;53393:272;;53440:60;;;;;;;;;;:::i;:::-;;;;;;;;53393:272;53615:6;53609:13;53600:6;53596:2;53592:15;53585:38;53151:529;53288:41;;;53278:51;;;:6;:51;;;;53271:58;;;;;53115:620;53719:4;53712:11;;52943:799;;;;;;;:::o;54314:126::-;;;;:::o;24321:387::-;24381:4;24589:12;24656:7;24644:20;24636:28;;24699:1;24692:4;:8;24685:15;;;24321:387;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:246::-;1879:1;1889:113;1903:6;1900:1;1897:13;1889:113;;;1988:1;1983:3;1979:11;1973:18;1969:1;1964:3;1960:11;1953:39;1925:2;1922:1;1918:10;1913:15;;1889:113;;;2036:1;2027:6;2022:3;2018:16;2011:27;1860:184;1798:246;;;:::o;2050:102::-;2091:6;2142:2;2138:7;2133:2;2126:5;2122:14;2118:28;2108:38;;2050:102;;;:::o;2158:377::-;2246:3;2274:39;2307:5;2274:39;:::i;:::-;2329:71;2393:6;2388:3;2329:71;:::i;:::-;2322:78;;2409:65;2467:6;2462:3;2455:4;2448:5;2444:16;2409:65;:::i;:::-;2499:29;2521:6;2499:29;:::i;:::-;2494:3;2490:39;2483:46;;2250:285;2158:377;;;;:::o;2541:313::-;2654:4;2692:2;2681:9;2677:18;2669:26;;2741:9;2735:4;2731:20;2727:1;2716:9;2712:17;2705:47;2769:78;2842:4;2833:6;2769:78;:::i;:::-;2761:86;;2541:313;;;;:::o;2860:77::-;2897:7;2926:5;2915:16;;2860:77;;;:::o;2943:122::-;3016:24;3034:5;3016:24;:::i;:::-;3009:5;3006:35;2996:63;;3055:1;3052;3045:12;2996:63;2943:122;:::o;3071:139::-;3117:5;3155:6;3142:20;3133:29;;3171:33;3198:5;3171:33;:::i;:::-;3071:139;;;;:::o;3216:329::-;3275:6;3324:2;3312:9;3303:7;3299:23;3295:32;3292:119;;;3330:79;;:::i;:::-;3292:119;3450:1;3475:53;3520:7;3511:6;3500:9;3496:22;3475:53;:::i;:::-;3465:63;;3421:117;3216:329;;;;:::o;3551:126::-;3588:7;3628:42;3621:5;3617:54;3606:65;;3551:126;;;:::o;3683:96::-;3720:7;3749:24;3767:5;3749:24;:::i;:::-;3738:35;;3683:96;;;:::o;3785:118::-;3872:24;3890:5;3872:24;:::i;:::-;3867:3;3860:37;3785:118;;:::o;3909:222::-;4002:4;4040:2;4029:9;4025:18;4017:26;;4053:71;4121:1;4110:9;4106:17;4097:6;4053:71;:::i;:::-;3909:222;;;;:::o;4137:122::-;4210:24;4228:5;4210:24;:::i;:::-;4203:5;4200:35;4190:63;;4249:1;4246;4239:12;4190:63;4137:122;:::o;4265:139::-;4311:5;4349:6;4336:20;4327:29;;4365:33;4392:5;4365:33;:::i;:::-;4265:139;;;;:::o;4410:474::-;4478:6;4486;4535:2;4523:9;4514:7;4510:23;4506:32;4503:119;;;4541:79;;:::i;:::-;4503:119;4661:1;4686:53;4731:7;4722:6;4711:9;4707:22;4686:53;:::i;:::-;4676:63;;4632:117;4788:2;4814:53;4859:7;4850:6;4839:9;4835:22;4814:53;:::i;:::-;4804:63;;4759:118;4410:474;;;;;:::o;4890:118::-;4977:24;4995:5;4977:24;:::i;:::-;4972:3;4965:37;4890:118;;:::o;5014:222::-;5107:4;5145:2;5134:9;5130:18;5122:26;;5158:71;5226:1;5215:9;5211:17;5202:6;5158:71;:::i;:::-;5014:222;;;;:::o;5242:619::-;5319:6;5327;5335;5384:2;5372:9;5363:7;5359:23;5355:32;5352:119;;;5390:79;;:::i;:::-;5352:119;5510:1;5535:53;5580:7;5571:6;5560:9;5556:22;5535:53;:::i;:::-;5525:63;;5481:117;5637:2;5663:53;5708:7;5699:6;5688:9;5684:22;5663:53;:::i;:::-;5653:63;;5608:118;5765:2;5791:53;5836:7;5827:6;5816:9;5812:22;5791:53;:::i;:::-;5781:63;;5736:118;5242:619;;;;;:::o;5867:60::-;5895:3;5916:5;5909:12;;5867:60;;;:::o;5933:142::-;5983:9;6016:53;6034:34;6043:24;6061:5;6043:24;:::i;:::-;6034:34;:::i;:::-;6016:53;:::i;:::-;6003:66;;5933:142;;;:::o;6081:126::-;6131:9;6164:37;6195:5;6164:37;:::i;:::-;6151:50;;6081:126;;;:::o;6213:157::-;6294:9;6327:37;6358:5;6327:37;:::i;:::-;6314:50;;6213:157;;;:::o;6376:193::-;6494:68;6556:5;6494:68;:::i;:::-;6489:3;6482:81;6376:193;;:::o;6575:284::-;6699:4;6737:2;6726:9;6722:18;6714:26;;6750:102;6849:1;6838:9;6834:17;6825:6;6750:102;:::i;:::-;6575:284;;;;:::o;6865:117::-;6974:1;6971;6964:12;6988:117;7097:1;7094;7087:12;7111:117;7220:1;7217;7210:12;7248:553;7306:8;7316:6;7366:3;7359:4;7351:6;7347:17;7343:27;7333:122;;7374:79;;:::i;:::-;7333:122;7487:6;7474:20;7464:30;;7517:18;7509:6;7506:30;7503:117;;;7539:79;;:::i;:::-;7503:117;7653:4;7645:6;7641:17;7629:29;;7707:3;7699:4;7691:6;7687:17;7677:8;7673:32;7670:41;7667:128;;;7714:79;;:::i;:::-;7667:128;7248:553;;;;;:::o;7807:529::-;7878:6;7886;7935:2;7923:9;7914:7;7910:23;7906:32;7903:119;;;7941:79;;:::i;:::-;7903:119;8089:1;8078:9;8074:17;8061:31;8119:18;8111:6;8108:30;8105:117;;;8141:79;;:::i;:::-;8105:117;8254:65;8311:7;8302:6;8291:9;8287:22;8254:65;:::i;:::-;8236:83;;;;8032:297;7807:529;;;;;:::o;8342:329::-;8401:6;8450:2;8438:9;8429:7;8425:23;8421:32;8418:119;;;8456:79;;:::i;:::-;8418:119;8576:1;8601:53;8646:7;8637:6;8626:9;8622:22;8601:53;:::i;:::-;8591:63;;8547:117;8342:329;;;;:::o;8677:116::-;8747:21;8762:5;8747:21;:::i;:::-;8740:5;8737:32;8727:60;;8783:1;8780;8773:12;8727:60;8677:116;:::o;8799:133::-;8842:5;8880:6;8867:20;8858:29;;8896:30;8920:5;8896:30;:::i;:::-;8799:133;;;;:::o;8938:468::-;9003:6;9011;9060:2;9048:9;9039:7;9035:23;9031:32;9028:119;;;9066:79;;:::i;:::-;9028:119;9186:1;9211:53;9256:7;9247:6;9236:9;9232:22;9211:53;:::i;:::-;9201:63;;9157:117;9313:2;9339:50;9381:7;9372:6;9361:9;9357:22;9339:50;:::i;:::-;9329:60;;9284:115;8938:468;;;;;:::o;9412:117::-;9521:1;9518;9511:12;9535:180;9583:77;9580:1;9573:88;9680:4;9677:1;9670:15;9704:4;9701:1;9694:15;9721:281;9804:27;9826:4;9804:27;:::i;:::-;9796:6;9792:40;9934:6;9922:10;9919:22;9898:18;9886:10;9883:34;9880:62;9877:88;;;9945:18;;:::i;:::-;9877:88;9985:10;9981:2;9974:22;9764:238;9721:281;;:::o;10008:129::-;10042:6;10069:20;;:::i;:::-;10059:30;;10098:33;10126:4;10118:6;10098:33;:::i;:::-;10008:129;;;:::o;10143:307::-;10204:4;10294:18;10286:6;10283:30;10280:56;;;10316:18;;:::i;:::-;10280:56;10354:29;10376:6;10354:29;:::i;:::-;10346:37;;10438:4;10432;10428:15;10420:23;;10143:307;;;:::o;10456:146::-;10553:6;10548:3;10543;10530:30;10594:1;10585:6;10580:3;10576:16;10569:27;10456:146;;;:::o;10608:423::-;10685:5;10710:65;10726:48;10767:6;10726:48;:::i;:::-;10710:65;:::i;:::-;10701:74;;10798:6;10791:5;10784:21;10836:4;10829:5;10825:16;10874:3;10865:6;10860:3;10856:16;10853:25;10850:112;;;10881:79;;:::i;:::-;10850:112;10971:54;11018:6;11013:3;11008;10971:54;:::i;:::-;10691:340;10608:423;;;;;:::o;11050:338::-;11105:5;11154:3;11147:4;11139:6;11135:17;11131:27;11121:122;;11162:79;;:::i;:::-;11121:122;11279:6;11266:20;11304:78;11378:3;11370:6;11363:4;11355:6;11351:17;11304:78;:::i;:::-;11295:87;;11111:277;11050:338;;;;:::o;11394:943::-;11489:6;11497;11505;11513;11562:3;11550:9;11541:7;11537:23;11533:33;11530:120;;;11569:79;;:::i;:::-;11530:120;11689:1;11714:53;11759:7;11750:6;11739:9;11735:22;11714:53;:::i;:::-;11704:63;;11660:117;11816:2;11842:53;11887:7;11878:6;11867:9;11863:22;11842:53;:::i;:::-;11832:63;;11787:118;11944:2;11970:53;12015:7;12006:6;11995:9;11991:22;11970:53;:::i;:::-;11960:63;;11915:118;12100:2;12089:9;12085:18;12072:32;12131:18;12123:6;12120:30;12117:117;;;12153:79;;:::i;:::-;12117:117;12258:62;12312:7;12303:6;12292:9;12288:22;12258:62;:::i;:::-;12248:72;;12043:287;11394:943;;;;;;;:::o;12343:474::-;12411:6;12419;12468:2;12456:9;12447:7;12443:23;12439:32;12436:119;;;12474:79;;:::i;:::-;12436:119;12594:1;12619:53;12664:7;12655:6;12644:9;12640:22;12619:53;:::i;:::-;12609:63;;12565:117;12721:2;12747:53;12792:7;12783:6;12772:9;12768:22;12747:53;:::i;:::-;12737:63;;12692:118;12343:474;;;;;:::o;12823:180::-;12871:77;12868:1;12861:88;12968:4;12965:1;12958:15;12992:4;12989:1;12982:15;13009:320;13053:6;13090:1;13084:4;13080:12;13070:22;;13137:1;13131:4;13127:12;13158:18;13148:81;;13214:4;13206:6;13202:17;13192:27;;13148:81;13276:2;13268:6;13265:14;13245:18;13242:38;13239:84;;13295:18;;:::i;:::-;13239:84;13060:269;13009:320;;;:::o;13335:231::-;13475:34;13471:1;13463:6;13459:14;13452:58;13544:14;13539:2;13531:6;13527:15;13520:39;13335:231;:::o;13572:366::-;13714:3;13735:67;13799:2;13794:3;13735:67;:::i;:::-;13728:74;;13811:93;13900:3;13811:93;:::i;:::-;13929:2;13924:3;13920:12;13913:19;;13572:366;;;:::o;13944:419::-;14110:4;14148:2;14137:9;14133:18;14125:26;;14197:9;14191:4;14187:20;14183:1;14172:9;14168:17;14161:47;14225:131;14351:4;14225:131;:::i;:::-;14217:139;;13944:419;;;:::o;14369:220::-;14509:34;14505:1;14497:6;14493:14;14486:58;14578:3;14573:2;14565:6;14561:15;14554:28;14369:220;:::o;14595:366::-;14737:3;14758:67;14822:2;14817:3;14758:67;:::i;:::-;14751:74;;14834:93;14923:3;14834:93;:::i;:::-;14952:2;14947:3;14943:12;14936:19;;14595:366;;;:::o;14967:419::-;15133:4;15171:2;15160:9;15156:18;15148:26;;15220:9;15214:4;15210:20;15206:1;15195:9;15191:17;15184:47;15248:131;15374:4;15248:131;:::i;:::-;15240:139;;14967:419;;;:::o;15392:243::-;15532:34;15528:1;15520:6;15516:14;15509:58;15601:26;15596:2;15588:6;15584:15;15577:51;15392:243;:::o;15641:366::-;15783:3;15804:67;15868:2;15863:3;15804:67;:::i;:::-;15797:74;;15880:93;15969:3;15880:93;:::i;:::-;15998:2;15993:3;15989:12;15982:19;;15641:366;;;:::o;16013:419::-;16179:4;16217:2;16206:9;16202:18;16194:26;;16266:9;16260:4;16256:20;16252:1;16241:9;16237:17;16230:47;16294:131;16420:4;16294:131;:::i;:::-;16286:139;;16013:419;;;:::o;16438:182::-;16578:34;16574:1;16566:6;16562:14;16555:58;16438:182;:::o;16626:366::-;16768:3;16789:67;16853:2;16848:3;16789:67;:::i;:::-;16782:74;;16865:93;16954:3;16865:93;:::i;:::-;16983:2;16978:3;16974:12;16967:19;;16626:366;;;:::o;16998:419::-;17164:4;17202:2;17191:9;17187:18;17179:26;;17251:9;17245:4;17241:20;17237:1;17226:9;17222:17;17215:47;17279:131;17405:4;17279:131;:::i;:::-;17271:139;;16998:419;;;:::o;17423:97::-;17482:6;17510:3;17500:13;;17423:97;;;;:::o;17526:141::-;17575:4;17598:3;17590:11;;17621:3;17618:1;17611:14;17655:4;17652:1;17642:18;17634:26;;17526:141;;;:::o;17673:93::-;17710:6;17757:2;17752;17745:5;17741:14;17737:23;17727:33;;17673:93;;;:::o;17772:107::-;17816:8;17866:5;17860:4;17856:16;17835:37;;17772:107;;;;:::o;17885:393::-;17954:6;18004:1;17992:10;17988:18;18027:97;18057:66;18046:9;18027:97;:::i;:::-;18145:39;18175:8;18164:9;18145:39;:::i;:::-;18133:51;;18217:4;18213:9;18206:5;18202:21;18193:30;;18266:4;18256:8;18252:19;18245:5;18242:30;18232:40;;17961:317;;17885:393;;;;;:::o;18284:142::-;18334:9;18367:53;18385:34;18394:24;18412:5;18394:24;:::i;:::-;18385:34;:::i;:::-;18367:53;:::i;:::-;18354:66;;18284:142;;;:::o;18432:75::-;18475:3;18496:5;18489:12;;18432:75;;;:::o;18513:269::-;18623:39;18654:7;18623:39;:::i;:::-;18684:91;18733:41;18757:16;18733:41;:::i;:::-;18725:6;18718:4;18712:11;18684:91;:::i;:::-;18678:4;18671:105;18589:193;18513:269;;;:::o;18788:73::-;18833:3;18788:73;:::o;18867:189::-;18944:32;;:::i;:::-;18985:65;19043:6;19035;19029:4;18985:65;:::i;:::-;18920:136;18867:189;;:::o;19062:186::-;19122:120;19139:3;19132:5;19129:14;19122:120;;;19193:39;19230:1;19223:5;19193:39;:::i;:::-;19166:1;19159:5;19155:13;19146:22;;19122:120;;;19062:186;;:::o;19254:543::-;19355:2;19350:3;19347:11;19344:446;;;19389:38;19421:5;19389:38;:::i;:::-;19473:29;19491:10;19473:29;:::i;:::-;19463:8;19459:44;19656:2;19644:10;19641:18;19638:49;;;19677:8;19662:23;;19638:49;19700:80;19756:22;19774:3;19756:22;:::i;:::-;19746:8;19742:37;19729:11;19700:80;:::i;:::-;19359:431;;19344:446;19254:543;;;:::o;19803:117::-;19857:8;19907:5;19901:4;19897:16;19876:37;;19803:117;;;;:::o;19926:169::-;19970:6;20003:51;20051:1;20047:6;20039:5;20036:1;20032:13;20003:51;:::i;:::-;19999:56;20084:4;20078;20074:15;20064:25;;19977:118;19926:169;;;;:::o;20100:295::-;20176:4;20322:29;20347:3;20341:4;20322:29;:::i;:::-;20314:37;;20384:3;20381:1;20377:11;20371:4;20368:21;20360:29;;20100:295;;;;:::o;20400:1403::-;20524:44;20564:3;20559;20524:44;:::i;:::-;20633:18;20625:6;20622:30;20619:56;;;20655:18;;:::i;:::-;20619:56;20699:38;20731:4;20725:11;20699:38;:::i;:::-;20784:67;20844:6;20836;20830:4;20784:67;:::i;:::-;20878:1;20907:2;20899:6;20896:14;20924:1;20919:632;;;;21595:1;21612:6;21609:84;;;21668:9;21663:3;21659:19;21646:33;21637:42;;21609:84;21719:67;21779:6;21772:5;21719:67;:::i;:::-;21713:4;21706:81;21568:229;20889:908;;20919:632;20971:4;20967:9;20959:6;20955:22;21005:37;21037:4;21005:37;:::i;:::-;21064:1;21078:215;21092:7;21089:1;21086:14;21078:215;;;21178:9;21173:3;21169:19;21156:33;21148:6;21141:49;21229:1;21221:6;21217:14;21207:24;;21276:2;21265:9;21261:18;21248:31;;21115:4;21112:1;21108:12;21103:17;;21078:215;;;21321:6;21312:7;21309:19;21306:186;;;21386:9;21381:3;21377:19;21364:33;21429:48;21471:4;21463:6;21459:17;21448:9;21429:48;:::i;:::-;21421:6;21414:64;21329:163;21306:186;21538:1;21534;21526:6;21522:14;21518:22;21512:4;21505:36;20926:625;;;20889:908;;20499:1304;;;20400:1403;;;:::o;21809:228::-;21949:34;21945:1;21937:6;21933:14;21926:58;22018:11;22013:2;22005:6;22001:15;21994:36;21809:228;:::o;22043:366::-;22185:3;22206:67;22270:2;22265:3;22206:67;:::i;:::-;22199:74;;22282:93;22371:3;22282:93;:::i;:::-;22400:2;22395:3;22391:12;22384:19;;22043:366;;;:::o;22415:419::-;22581:4;22619:2;22608:9;22604:18;22596:26;;22668:9;22662:4;22658:20;22654:1;22643:9;22639:17;22632:47;22696:131;22822:4;22696:131;:::i;:::-;22688:139;;22415:419;;;:::o;22840:229::-;22980:34;22976:1;22968:6;22964:14;22957:58;23049:12;23044:2;23036:6;23032:15;23025:37;22840:229;:::o;23075:366::-;23217:3;23238:67;23302:2;23297:3;23238:67;:::i;:::-;23231:74;;23314:93;23403:3;23314:93;:::i;:::-;23432:2;23427:3;23423:12;23416:19;;23075:366;;;:::o;23447:419::-;23613:4;23651:2;23640:9;23636:18;23628:26;;23700:9;23694:4;23690:20;23686:1;23675:9;23671:17;23664:47;23728:131;23854:4;23728:131;:::i;:::-;23720:139;;23447:419;;;:::o;23872:169::-;24012:21;24008:1;24000:6;23996:14;23989:45;23872:169;:::o;24047:366::-;24189:3;24210:67;24274:2;24269:3;24210:67;:::i;:::-;24203:74;;24286:93;24375:3;24286:93;:::i;:::-;24404:2;24399:3;24395:12;24388:19;;24047:366;;;:::o;24419:419::-;24585:4;24623:2;24612:9;24608:18;24600:26;;24672:9;24666:4;24662:20;24658:1;24647:9;24643:17;24636:47;24700:131;24826:4;24700:131;:::i;:::-;24692:139;;24419:419;;;:::o;24844:168::-;24984:20;24980:1;24972:6;24968:14;24961:44;24844:168;:::o;25018:366::-;25160:3;25181:67;25245:2;25240:3;25181:67;:::i;:::-;25174:74;;25257:93;25346:3;25257:93;:::i;:::-;25375:2;25370:3;25366:12;25359:19;;25018:366;;;:::o;25390:419::-;25556:4;25594:2;25583:9;25579:18;25571:26;;25643:9;25637:4;25633:20;25629:1;25618:9;25614:17;25607:47;25671:131;25797:4;25671:131;:::i;:::-;25663:139;;25390:419;;;:::o;25815:175::-;25955:27;25951:1;25943:6;25939:14;25932:51;25815:175;:::o;25996:366::-;26138:3;26159:67;26223:2;26218:3;26159:67;:::i;:::-;26152:74;;26235:93;26324:3;26235:93;:::i;:::-;26353:2;26348:3;26344:12;26337:19;;25996:366;;;:::o;26368:419::-;26534:4;26572:2;26561:9;26557:18;26549:26;;26621:9;26615:4;26611:20;26607:1;26596:9;26592:17;26585:47;26649:131;26775:4;26649:131;:::i;:::-;26641:139;;26368:419;;;:::o;26793:180::-;26841:77;26838:1;26831:88;26938:4;26935:1;26928:15;26962:4;26959:1;26952:15;26979:191;27019:3;27038:20;27056:1;27038:20;:::i;:::-;27033:25;;27072:20;27090:1;27072:20;:::i;:::-;27067:25;;27115:1;27112;27108:9;27101:16;;27136:3;27133:1;27130:10;27127:36;;;27143:18;;:::i;:::-;27127:36;26979:191;;;;:::o;27176:233::-;27215:3;27238:24;27256:5;27238:24;:::i;:::-;27229:33;;27284:66;27277:5;27274:77;27271:103;;27354:18;;:::i;:::-;27271:103;27401:1;27394:5;27390:13;27383:20;;27176:233;;;:::o;27415:175::-;27555:27;27551:1;27543:6;27539:14;27532:51;27415:175;:::o;27596:366::-;27738:3;27759:67;27823:2;27818:3;27759:67;:::i;:::-;27752:74;;27835:93;27924:3;27835:93;:::i;:::-;27953:2;27948:3;27944:12;27937:19;;27596:366;;;:::o;27968:419::-;28134:4;28172:2;28161:9;28157:18;28149:26;;28221:9;28215:4;28211:20;28207:1;28196:9;28192:17;28185:47;28249:131;28375:4;28249:131;:::i;:::-;28241:139;;27968:419;;;:::o;28393:234::-;28533:34;28529:1;28521:6;28517:14;28510:58;28602:17;28597:2;28589:6;28585:15;28578:42;28393:234;:::o;28633:366::-;28775:3;28796:67;28860:2;28855:3;28796:67;:::i;:::-;28789:74;;28872:93;28961:3;28872:93;:::i;:::-;28990:2;28985:3;28981:12;28974:19;;28633:366;;;:::o;29005:419::-;29171:4;29209:2;29198:9;29194:18;29186:26;;29258:9;29252:4;29248:20;29244:1;29233:9;29229:17;29222:47;29286:131;29412:4;29286:131;:::i;:::-;29278:139;;29005:419;;;:::o;29430:148::-;29532:11;29569:3;29554:18;;29430:148;;;;:::o;29584:390::-;29690:3;29718:39;29751:5;29718:39;:::i;:::-;29773:89;29855:6;29850:3;29773:89;:::i;:::-;29766:96;;29871:65;29929:6;29924:3;29917:4;29910:5;29906:16;29871:65;:::i;:::-;29961:6;29956:3;29952:16;29945:23;;29694:280;29584:390;;;;:::o;29980:435::-;30160:3;30182:95;30273:3;30264:6;30182:95;:::i;:::-;30175:102;;30294:95;30385:3;30376:6;30294:95;:::i;:::-;30287:102;;30406:3;30399:10;;29980:435;;;;;:::o;30421:169::-;30561:21;30557:1;30549:6;30545:14;30538:45;30421:169;:::o;30596:366::-;30738:3;30759:67;30823:2;30818:3;30759:67;:::i;:::-;30752:74;;30835:93;30924:3;30835:93;:::i;:::-;30953:2;30948:3;30944:12;30937:19;;30596:366;;;:::o;30968:419::-;31134:4;31172:2;31161:9;31157:18;31149:26;;31221:9;31215:4;31211:20;31207:1;31196:9;31192:17;31185:47;31249:131;31375:4;31249:131;:::i;:::-;31241:139;;30968:419;;;:::o;31393:181::-;31533:33;31529:1;31521:6;31517:14;31510:57;31393:181;:::o;31580:366::-;31722:3;31743:67;31807:2;31802:3;31743:67;:::i;:::-;31736:74;;31819:93;31908:3;31819:93;:::i;:::-;31937:2;31932:3;31928:12;31921:19;;31580:366;;;:::o;31952:419::-;32118:4;32156:2;32145:9;32141:18;32133:26;;32205:9;32199:4;32195:20;32191:1;32180:9;32176:17;32169:47;32233:131;32359:4;32233:131;:::i;:::-;32225:139;;31952:419;;;:::o;32377:165::-;32517:17;32513:1;32505:6;32501:14;32494:41;32377:165;:::o;32548:366::-;32690:3;32711:67;32775:2;32770:3;32711:67;:::i;:::-;32704:74;;32787:93;32876:3;32787:93;:::i;:::-;32905:2;32900:3;32896:12;32889:19;;32548:366;;;:::o;32920:419::-;33086:4;33124:2;33113:9;33109:18;33101:26;;33173:9;33167:4;33163:20;33159:1;33148:9;33144:17;33137:47;33201:131;33327:4;33201:131;:::i;:::-;33193:139;;32920:419;;;:::o;33345:164::-;33485:16;33481:1;33473:6;33469:14;33462:40;33345:164;:::o;33515:366::-;33657:3;33678:67;33742:2;33737:3;33678:67;:::i;:::-;33671:74;;33754:93;33843:3;33754:93;:::i;:::-;33872:2;33867:3;33863:12;33856:19;;33515:366;;;:::o;33887:419::-;34053:4;34091:2;34080:9;34076:18;34068:26;;34140:9;34134:4;34130:20;34126:1;34115:9;34111:17;34104:47;34168:131;34294:4;34168:131;:::i;:::-;34160:139;;33887:419;;;:::o;34312:225::-;34452:34;34448:1;34440:6;34436:14;34429:58;34521:8;34516:2;34508:6;34504:15;34497:33;34312:225;:::o;34543:366::-;34685:3;34706:67;34770:2;34765:3;34706:67;:::i;:::-;34699:74;;34782:93;34871:3;34782:93;:::i;:::-;34900:2;34895:3;34891:12;34884:19;;34543:366;;;:::o;34915:419::-;35081:4;35119:2;35108:9;35104:18;35096:26;;35168:9;35162:4;35158:20;35154:1;35143:9;35139:17;35132:47;35196:131;35322:4;35196:131;:::i;:::-;35188:139;;34915:419;;;:::o;35340:332::-;35461:4;35499:2;35488:9;35484:18;35476:26;;35512:71;35580:1;35569:9;35565:17;35556:6;35512:71;:::i;:::-;35593:72;35661:2;35650:9;35646:18;35637:6;35593:72;:::i;:::-;35340:332;;;;;:::o;35678:137::-;35732:5;35763:6;35757:13;35748:22;;35779:30;35803:5;35779:30;:::i;:::-;35678:137;;;;:::o;35821:345::-;35888:6;35937:2;35925:9;35916:7;35912:23;35908:32;35905:119;;;35943:79;;:::i;:::-;35905:119;36063:1;36088:61;36141:7;36132:6;36121:9;36117:22;36088:61;:::i;:::-;36078:71;;36034:125;35821:345;;;;:::o;36172:236::-;36312:34;36308:1;36300:6;36296:14;36289:58;36381:19;36376:2;36368:6;36364:15;36357:44;36172:236;:::o;36414:366::-;36556:3;36577:67;36641:2;36636:3;36577:67;:::i;:::-;36570:74;;36653:93;36742:3;36653:93;:::i;:::-;36771:2;36766:3;36762:12;36755:19;;36414:366;;;:::o;36786:419::-;36952:4;36990:2;36979:9;36975:18;36967:26;;37039:9;37033:4;37029:20;37025:1;37014:9;37010:17;37003:47;37067:131;37193:4;37067:131;:::i;:::-;37059:139;;36786:419;;;:::o;37211:180::-;37259:77;37256:1;37249:88;37356:4;37353:1;37346:15;37380:4;37377:1;37370:15;37397:185;37437:1;37454:20;37472:1;37454:20;:::i;:::-;37449:25;;37488:20;37506:1;37488:20;:::i;:::-;37483:25;;37527:1;37517:35;;37532:18;;:::i;:::-;37517:35;37574:1;37571;37567:9;37562:14;;37397:185;;;;:::o;37588:194::-;37628:4;37648:20;37666:1;37648:20;:::i;:::-;37643:25;;37682:20;37700:1;37682:20;:::i;:::-;37677:25;;37726:1;37723;37719:9;37711:17;;37750:1;37744:4;37741:11;37738:37;;;37755:18;;:::i;:::-;37738:37;37588:194;;;;:::o;37788:176::-;37820:1;37837:20;37855:1;37837:20;:::i;:::-;37832:25;;37871:20;37889:1;37871:20;:::i;:::-;37866:25;;37910:1;37900:35;;37915:18;;:::i;:::-;37900:35;37956:1;37953;37949:9;37944:14;;37788:176;;;;:::o;37970:180::-;38018:77;38015:1;38008:88;38115:4;38112:1;38105:15;38139:4;38136:1;38129:15;38156:410;38196:7;38219:20;38237:1;38219:20;:::i;:::-;38214:25;;38253:20;38271:1;38253:20;:::i;:::-;38248:25;;38308:1;38305;38301:9;38330:30;38348:11;38330:30;:::i;:::-;38319:41;;38509:1;38500:7;38496:15;38493:1;38490:22;38470:1;38463:9;38443:83;38420:139;;38539:18;;:::i;:::-;38420:139;38204:362;38156:410;;;;:::o;38572:231::-;38712:34;38708:1;38700:6;38696:14;38689:58;38781:14;38776:2;38768:6;38764:15;38757:39;38572:231;:::o;38809:366::-;38951:3;38972:67;39036:2;39031:3;38972:67;:::i;:::-;38965:74;;39048:93;39137:3;39048:93;:::i;:::-;39166:2;39161:3;39157:12;39150:19;;38809:366;;;:::o;39181:419::-;39347:4;39385:2;39374:9;39370:18;39362:26;;39434:9;39428:4;39424:20;39420:1;39409:9;39405:17;39398:47;39462:131;39588:4;39462:131;:::i;:::-;39454:139;;39181:419;;;:::o;39606:228::-;39746:34;39742:1;39734:6;39730:14;39723:58;39815:11;39810:2;39802:6;39798:15;39791:36;39606:228;:::o;39840:366::-;39982:3;40003:67;40067:2;40062:3;40003:67;:::i;:::-;39996:74;;40079:93;40168:3;40079:93;:::i;:::-;40197:2;40192:3;40188:12;40181:19;;39840:366;;;:::o;40212:419::-;40378:4;40416:2;40405:9;40401:18;40393:26;;40465:9;40459:4;40455:20;40451:1;40440:9;40436:17;40429:47;40493:131;40619:4;40493:131;:::i;:::-;40485:139;;40212:419;;;:::o;40637:223::-;40777:34;40773:1;40765:6;40761:14;40754:58;40846:6;40841:2;40833:6;40829:15;40822:31;40637:223;:::o;40866:366::-;41008:3;41029:67;41093:2;41088:3;41029:67;:::i;:::-;41022:74;;41105:93;41194:3;41105:93;:::i;:::-;41223:2;41218:3;41214:12;41207:19;;40866:366;;;:::o;41238:419::-;41404:4;41442:2;41431:9;41427:18;41419:26;;41491:9;41485:4;41481:20;41477:1;41466:9;41462:17;41455:47;41519:131;41645:4;41519:131;:::i;:::-;41511:139;;41238:419;;;:::o;41663:237::-;41803:34;41799:1;41791:6;41787:14;41780:58;41872:20;41867:2;41859:6;41855:15;41848:45;41663:237;:::o;41906:366::-;42048:3;42069:67;42133:2;42128:3;42069:67;:::i;:::-;42062:74;;42145:93;42234:3;42145:93;:::i;:::-;42263:2;42258:3;42254:12;42247:19;;41906:366;;;:::o;42278:419::-;42444:4;42482:2;42471:9;42467:18;42459:26;;42531:9;42525:4;42521:20;42517:1;42506:9;42502:17;42495:47;42559:131;42685:4;42559:131;:::i;:::-;42551:139;;42278:419;;;:::o;42703:182::-;42843:34;42839:1;42831:6;42827:14;42820:58;42703:182;:::o;42891:366::-;43033:3;43054:67;43118:2;43113:3;43054:67;:::i;:::-;43047:74;;43130:93;43219:3;43130:93;:::i;:::-;43248:2;43243:3;43239:12;43232:19;;42891:366;;;:::o;43263:419::-;43429:4;43467:2;43456:9;43452:18;43444:26;;43516:9;43510:4;43506:20;43502:1;43491:9;43487:17;43480:47;43544:131;43670:4;43544:131;:::i;:::-;43536:139;;43263:419;;;:::o;43688:178::-;43828:30;43824:1;43816:6;43812:14;43805:54;43688:178;:::o;43872:366::-;44014:3;44035:67;44099:2;44094:3;44035:67;:::i;:::-;44028:74;;44111:93;44200:3;44111:93;:::i;:::-;44229:2;44224:3;44220:12;44213:19;;43872:366;;;:::o;44244:419::-;44410:4;44448:2;44437:9;44433:18;44425:26;;44497:9;44491:4;44487:20;44483:1;44472:9;44468:17;44461:47;44525:131;44651:4;44525:131;:::i;:::-;44517:139;;44244:419;;;:::o;44669:98::-;44720:6;44754:5;44748:12;44738:22;;44669:98;;;:::o;44773:168::-;44856:11;44890:6;44885:3;44878:19;44930:4;44925:3;44921:14;44906:29;;44773:168;;;;:::o;44947:373::-;45033:3;45061:38;45093:5;45061:38;:::i;:::-;45115:70;45178:6;45173:3;45115:70;:::i;:::-;45108:77;;45194:65;45252:6;45247:3;45240:4;45233:5;45229:16;45194:65;:::i;:::-;45284:29;45306:6;45284:29;:::i;:::-;45279:3;45275:39;45268:46;;45037:283;44947:373;;;;:::o;45326:640::-;45521:4;45559:3;45548:9;45544:19;45536:27;;45573:71;45641:1;45630:9;45626:17;45617:6;45573:71;:::i;:::-;45654:72;45722:2;45711:9;45707:18;45698:6;45654:72;:::i;:::-;45736;45804:2;45793:9;45789:18;45780:6;45736:72;:::i;:::-;45855:9;45849:4;45845:20;45840:2;45829:9;45825:18;45818:48;45883:76;45954:4;45945:6;45883:76;:::i;:::-;45875:84;;45326:640;;;;;;;:::o;45972:141::-;46028:5;46059:6;46053:13;46044:22;;46075:32;46101:5;46075:32;:::i;:::-;45972:141;;;;:::o;46119:349::-;46188:6;46237:2;46225:9;46216:7;46212:23;46208:32;46205:119;;;46243:79;;:::i;:::-;46205:119;46363:1;46388:63;46443:7;46434:6;46423:9;46419:22;46388:63;:::i;:::-;46378:73;;46334:127;46119:349;;;;:::o

Swarm Source

ipfs://8c3c34b778b42028d2b3ebb029001d005dca7262e28f832eb59ea525e5d88b37

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services