Token

Fidn404 (Fidn404)

ERC-1155

Overview

Max Total Supply

10,000 Fidn404

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x6612f995bdf604ff2a86cb368d9417a586c7a29f

Filtered by Token Holder

0xd8f98F031038d6ADE8fb817bcc212A27935136af

0xd8f98f031038d6ade8fb817bcc212a27935136af

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Fidn404

Compiler Version

v0.8.24+commit.e11b9ed9

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2024-02-12
*/

/**
Twitter/x   : https://twitter.com/fidn404
*/
/**
    A better ERC404 Fido Dido Genesis Cards
 */
//Inspired by all the great work out there from ERC20, 404, 721, 721a, 721Psi, 1155, 1155Delta
// SPDX-License-Identifier: MIT
pragma solidity 0.8.24;

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

    function _msgData() internal view virtual returns (bytes calldata) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

/**
 * @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.
 *
 * The initial owner is set to the address provided by the deployer. 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;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

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

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

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

interface IERC20 {
    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address to, uint256 value) external returns (bool);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);
}

interface IERC20Metadata is IERC20 {
    function name() external view returns (string memory);

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

    function decimals() external view returns (uint8);
}

interface IERC20Errors {
    error ERC20InsufficientBalance(
        address sender,
        uint256 balance,
        uint256 needed
    );
    error ERC20InvalidSender(address sender);
    error ERC20InvalidReceiver(address receiver);
    error ERC20InsufficientAllowance(
        address spender,
        uint256 allowance,
        uint256 needed
    );
    error ERC20InvalidApprover(address approver);
    error ERC20InvalidSpender(address spender);
}

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

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

interface IERCX {
    /**
     * The caller must own the token or be an approved operator.
     */
    error ApprovalCallerNotOwnerNorApproved();

    /**
     * Cannot query the balance for the zero address.
     */
    error BalanceQueryForZeroAddress();

    /**
     * Cannot mint to the zero address.
     */
    error MintToZeroAddress();

    /**
     * The quantity of tokens minted must be more than zero.
     */
    error MintZeroQuantity();

    /**
     * Cannot burn from the zero address.
     */
    error BurnFromZeroAddress();

    /**
     * Cannot burn from the address that doesn't owne the token.
     */
    error BurnFromNonOnwerAddress();

    /**
     * The caller must own the token or be an approved operator.
     */
    error TransferCallerNotOwnerNorApproved();

    /**
     * The token must be owned by `from` or the `amount` is not 1.
     */
    error TransferFromIncorrectOwnerOrInvalidAmount();

    /**
     * Cannot safely transfer to a contract that does not implement the
     * ERC1155Receiver interface.
     */
    error TransferToNonERC1155ReceiverImplementer();
    error TransferToNonERC721ReceiverImplementer();

    /**
     * Cannot transfer to the zero address.
     */
    error TransferToZeroAddress();

    /**
     * The length of input arraies is not matching.
     */
    error InputLengthMistmatch();

    function isOwnerOf(address account, uint256 id)
        external
        view
        returns (bool);
}

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

/**
 * @dev Interface that must be implemented by smart contracts in order to receive
 * ERC-1155 token transfers.
 */
interface IERC1155Receiver is IERC165 {
    /**
     * @dev Handles the receipt of a single ERC1155 token type. This function is
     * called at the end of a `safeTransferFrom` after the balance has been updated.
     *
     * NOTE: To accept the transfer, this must return
     * `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))`
     * (i.e. 0xf23a6e61, or its own function selector).
     *
     * @param operator The address which initiated the transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param id The ID of the token being transferred
     * @param value The amount of tokens being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155Received(address,address,uint256,uint256,bytes)"))` if transfer is allowed
     */
    function onERC1155Received(
        address operator,
        address from,
        uint256 id,
        uint256 value,
        bytes calldata data
    ) external returns (bytes4);

    /**
     * @dev Handles the receipt of a multiple ERC1155 token types. This function
     * is called at the end of a `safeBatchTransferFrom` after the balances have
     * been updated.
     *
     * NOTE: To accept the transfer(s), this must return
     * `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))`
     * (i.e. 0xbc197c81, or its own function selector).
     *
     * @param operator The address which initiated the batch transfer (i.e. msg.sender)
     * @param from The address which previously owned the token
     * @param ids An array containing ids of each token being transferred (order and length must match values array)
     * @param values An array containing amounts of each token being transferred (order and length must match ids array)
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)"))` if transfer is allowed
     */
    function onERC1155BatchReceived(
        address operator,
        address from,
        uint256[] calldata ids,
        uint256[] calldata values,
        bytes calldata data
    ) external returns (bytes4);
}

abstract contract ERC721Receiver {
    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external virtual returns (bytes4) {
        return ERC721Receiver.onERC721Received.selector;
    }
}

/**
 * @dev Required interface of an ERC1155 compliant contract, as defined in the
 * https://eips.ethereum.org/EIPS/eip-1155[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155 is IERC165 {
    /**
     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.
     */
    event TransferSingle(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256 id,
        uint256 value
    );

    /**
     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all
     * transfers.
     */
    event TransferBatch(
        address indexed operator,
        address indexed from,
        address indexed to,
        uint256[] ids,
        uint256[] values
    );

    /**
     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to
     * `approved`.
     */
    event ApprovalForAll(
        address indexed account,
        address indexed operator,
        bool approved
    );

    /**
     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.
     *
     * If an {URI} event was emitted for `id`, the standard
     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value
     * returned by {IERC1155MetadataURI-uri}.
     */
    event URI(string value, uint256 indexed id);

    /**
     * @dev Returns the amount of tokens of token type `id` owned by `account`.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id)
        external
        view
        returns (uint256);

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)
        external
        view
        returns (uint256[] memory);

    /**
     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,
     *
     * Emits an {ApprovalForAll} event.
     *
     * Requirements:
     *
     * - `operator` cannot be the caller.
     */
    function setApprovalForAll(address operator, bool approved) external;

    /**
     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.
     *
     * See {setApprovalForAll}.
     */
    function isApprovedForAll(address account, address operator)
        external
        view
        returns (bool);

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If the caller is not `from`, it must be have been approved to spend ``from``'s tokens via {setApprovalForAll}.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes calldata data
    ) external;

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] calldata ids,
        uint256[] calldata amounts,
        bytes calldata data
    ) external;
}

/**
 * @dev Interface of the optional ERC1155MetadataExtension interface, as defined
 * in the https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[EIP].
 *
 * _Available since v3.1._
 */
interface IERC1155MetadataURI is IERC1155 {
    /**
     * @dev Returns the URI for token type `id`.
     *
     * If the `\{id\}` substring is present in the URI, it must be replaced by
     * clients with the actual token type ID.
     */
    function uri(uint256 id) external view returns (string memory);
}

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

/// @notice Library for bit twiddling and boolean operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBit.sol)
/// @author Inspired by (https://graphics.stanford.edu/~seander/bithacks.html)
library LibBit {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  BIT TWIDDLING OPERATIONS                  */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Find last set.
    /// Returns the index of the most significant bit of `x`,
    /// counting from the least significant bit position.
    /// If `x` is zero, returns 256.
    function fls(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            r := or(
                shl(8, iszero(x)),
                shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
            )
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            r := or(
                r,
                byte(
                    and(
                        0x1f,
                        shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)
                    ),
                    0x0706060506020504060203020504030106050205030304010505030400000000
                )
            )
        }
    }

    /// @dev Count leading zeros.
    /// Returns the number of zeros preceding the most significant one bit.
    /// If `x` is zero, returns 256.
    function clz(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            r := shl(7, lt(0xffffffffffffffffffffffffffffffff, x))
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, x))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, x))))
            r := or(r, shl(4, lt(0xffff, shr(r, x))))
            r := or(r, shl(3, lt(0xff, shr(r, x))))
            // forgefmt: disable-next-item
            r := add(
                xor(
                    r,
                    byte(
                        and(
                            0x1f,
                            shr(shr(r, x), 0x8421084210842108cc6318c6db6d54be)
                        ),
                        0xf8f9f9faf9fdfafbf9fdfcfdfafbfcfef9fafdfafcfcfbfefafafcfbffffffff
                    )
                ),
                iszero(x)
            )
        }
    }

    /// @dev Find first set.
    /// Returns the index of the least significant bit of `x`,
    /// counting from the least significant bit position.
    /// If `x` is zero, returns 256.
    /// Equivalent to `ctz` (count trailing zeros), which gives
    /// the number of zeros following the least significant one bit.
    function ffs(uint256 x) internal pure returns (uint256 r) {
        /// @solidity memory-safe-assembly
        assembly {
            // Isolate the least significant bit.
            let b := and(x, add(not(x), 1))

            r := or(
                shl(8, iszero(x)),
                shl(7, lt(0xffffffffffffffffffffffffffffffff, b))
            )
            r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, b))))
            r := or(r, shl(5, lt(0xffffffff, shr(r, b))))

            // For the remaining 32 bits, use a De Bruijn lookup.
            // forgefmt: disable-next-item
            r := or(
                r,
                byte(
                    and(div(0xd76453e0, shr(r, b)), 0x1f),
                    0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405
                )
            )
        }
    }

    /// @dev Returns the number of set bits in `x`.
    function popCount(uint256 x) internal pure returns (uint256 c) {
        /// @solidity memory-safe-assembly
        assembly {
            let max := not(0)
            let isMax := eq(x, max)
            x := sub(x, and(shr(1, x), div(max, 3)))
            x := add(and(x, div(max, 5)), and(shr(2, x), div(max, 5)))
            x := and(add(x, shr(4, x)), div(max, 17))
            c := or(shl(8, isMax), shr(248, mul(x, div(max, 255))))
        }
    }

    /// @dev Returns whether `x` is a power of 2.
    function isPo2(uint256 x) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Equivalent to `x && !(x & (x - 1))`.
            result := iszero(add(and(x, sub(x, 1)), iszero(x)))
        }
    }

    /// @dev Returns `x` reversed at the bit level.
    function reverseBits(uint256 x) internal pure returns (uint256 r) {
        uint256 m0 = 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f;
        uint256 m1 = m0 ^ (m0 << 2);
        uint256 m2 = m1 ^ (m1 << 1);
        r = reverseBytes(x);
        r = (m2 & (r >> 1)) | ((m2 & r) << 1);
        r = (m1 & (r >> 2)) | ((m1 & r) << 2);
        r = (m0 & (r >> 4)) | ((m0 & r) << 4);
    }

    /// @dev Returns `x` reversed at the byte level.
    function reverseBytes(uint256 x) internal pure returns (uint256 r) {
        unchecked {
            // Computing masks on-the-fly reduces bytecode size by about 200 bytes.
            uint256 m0 = 0x100000000000000000000000000000001 *
                (~toUint(x == 0) >> 192);
            uint256 m1 = m0 ^ (m0 << 32);
            uint256 m2 = m1 ^ (m1 << 16);
            uint256 m3 = m2 ^ (m2 << 8);
            r = (m3 & (x >> 8)) | ((m3 & x) << 8);
            r = (m2 & (r >> 16)) | ((m2 & r) << 16);
            r = (m1 & (r >> 32)) | ((m1 & r) << 32);
            r = (m0 & (r >> 64)) | ((m0 & r) << 64);
            r = (r >> 128) | (r << 128);
        }
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                     BOOLEAN OPERATIONS                     */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    // A Solidity bool on the stack or memory is represented as a 256-bit word.
    // Non-zero values are true, zero is false.
    // A clean bool is either 0 (false) or 1 (true) under the hood.
    // Usually, if not always, the bool result of a regular Solidity expression,
    // or the argument of a public/external function will be a clean bool.
    // You can usually use the raw variants for more performance.
    // If uncertain, test (best with exact compiler settings).
    // Or use the non-raw variants (compiler can sometimes optimize out the double `iszero`s).

    /// @dev Returns `x & y`. Inputs must be clean.
    function rawAnd(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := and(x, y)
        }
    }

    /// @dev Returns `x & y`.
    function and(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := and(iszero(iszero(x)), iszero(iszero(y)))
        }
    }

    /// @dev Returns `x | y`. Inputs must be clean.
    function rawOr(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := or(x, y)
        }
    }

    /// @dev Returns `x | y`.
    function or(bool x, bool y) internal pure returns (bool z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := or(iszero(iszero(x)), iszero(iszero(y)))
        }
    }

    /// @dev Returns 1 if `b` is true, else 0. Input must be clean.
    function rawToUint(bool b) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := b
        }
    }

    /// @dev Returns 1 if `b` is true, else 0.
    function toUint(bool b) internal pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := iszero(iszero(b))
        }
    }
}

/// @notice Library for storage of packed unsigned booleans.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBitmap.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibBitmap.sol)
/// @author Modified from Solidity-Bits (https://github.com/estarriolvetch/solidity-bits/blob/main/contracts/BitMaps.sol)
library LibBitmap {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The constant returned when a bitmap scan does not find a result.
    uint256 internal constant NOT_FOUND = type(uint256).max;

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev A bitmap in storage.
    struct Bitmap {
        mapping(uint256 => uint256) map;
    }

    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         OPERATIONS                         */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev Returns the boolean value of the bit at `index` in `bitmap`.
    function get(Bitmap storage bitmap, uint256 index)
        internal
        view
        returns (bool isSet)
    {
        // It is better to set `isSet` to either 0 or 1, than zero vs non-zero.
        // Both cost the same amount of gas, but the former allows the returned value
        // to be reused without cleaning the upper bits.
        uint256 b = (bitmap.map[index >> 8] >> (index & 0xff)) & 1;
        /// @solidity memory-safe-assembly
        assembly {
            isSet := b
        }
    }

    /// @dev Updates the bit at `index` in `bitmap` to true.
    function set(Bitmap storage bitmap, uint256 index) internal {
        bitmap.map[index >> 8] |= (1 << (index & 0xff));
    }

    /// @dev Updates the bit at `index` in `bitmap` to false.
    function unset(Bitmap storage bitmap, uint256 index) internal {
        bitmap.map[index >> 8] &= ~(1 << (index & 0xff));
    }

    /// @dev Flips the bit at `index` in `bitmap`.
    /// Returns the boolean result of the flipped bit.
    function toggle(Bitmap storage bitmap, uint256 index)
        internal
        returns (bool newIsSet)
    {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, index))
            let storageSlot := keccak256(0x00, 0x40)
            let shift := and(index, 0xff)
            let storageValue := xor(sload(storageSlot), shl(shift, 1))
            // It makes sense to return the `newIsSet`,
            // as it allow us to skip an additional warm `sload`,
            // and it costs minimal gas (about 15),
            // which may be optimized away if the returned value is unused.
            newIsSet := and(1, shr(shift, storageValue))
            sstore(storageSlot, storageValue)
        }
    }

    /// @dev Updates the bit at `index` in `bitmap` to `shouldSet`.
    function setTo(
        Bitmap storage bitmap,
        uint256 index,
        bool shouldSet
    ) internal {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, index))
            let storageSlot := keccak256(0x00, 0x40)
            let storageValue := sload(storageSlot)
            let shift := and(index, 0xff)
            sstore(
                storageSlot,
                // Unsets the bit at `shift` via `and`, then sets its new value via `or`.
                or(
                    and(storageValue, not(shl(shift, 1))),
                    shl(shift, iszero(iszero(shouldSet)))
                )
            )
        }
    }

    /// @dev Consecutively sets `amount` of bits starting from the bit at `start`.
    function setBatch(
        Bitmap storage bitmap,
        uint256 start,
        uint256 amount
    ) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let max := not(0)
            let shift := and(start, 0xff)
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, start))
            if iszero(lt(add(shift, amount), 257)) {
                let storageSlot := keccak256(0x00, 0x40)
                sstore(storageSlot, or(sload(storageSlot), shl(shift, max)))
                let bucket := add(mload(0x00), 1)
                let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
                amount := and(add(amount, shift), 0xff)
                shift := 0
                for {

                } iszero(eq(bucket, bucketEnd)) {
                    bucket := add(bucket, 1)
                } {
                    mstore(0x00, bucket)
                    sstore(keccak256(0x00, 0x40), max)
                }
                mstore(0x00, bucket)
            }
            let storageSlot := keccak256(0x00, 0x40)
            sstore(
                storageSlot,
                or(sload(storageSlot), shl(shift, shr(sub(256, amount), max)))
            )
        }
    }

    /// @dev Consecutively unsets `amount` of bits starting from the bit at `start`.
    function unsetBatch(
        Bitmap storage bitmap,
        uint256 start,
        uint256 amount
    ) internal {
        /// @solidity memory-safe-assembly
        assembly {
            let shift := and(start, 0xff)
            mstore(0x20, bitmap.slot)
            mstore(0x00, shr(8, start))
            if iszero(lt(add(shift, amount), 257)) {
                let storageSlot := keccak256(0x00, 0x40)
                sstore(
                    storageSlot,
                    and(sload(storageSlot), not(shl(shift, not(0))))
                )
                let bucket := add(mload(0x00), 1)
                let bucketEnd := add(mload(0x00), shr(8, add(amount, shift)))
                amount := and(add(amount, shift), 0xff)
                shift := 0
                for {

                } iszero(eq(bucket, bucketEnd)) {
                    bucket := add(bucket, 1)
                } {
                    mstore(0x00, bucket)
                    sstore(keccak256(0x00, 0x40), 0)
                }
                mstore(0x00, bucket)
            }
            let storageSlot := keccak256(0x00, 0x40)
            sstore(
                storageSlot,
                and(
                    sload(storageSlot),
                    not(shl(shift, shr(sub(256, amount), not(0))))
                )
            )
        }
    }

    /// @dev Returns number of set bits within a range by
    /// scanning `amount` of bits starting from the bit at `start`.
    function popCount(
        Bitmap storage bitmap,
        uint256 start,
        uint256 amount
    ) internal view returns (uint256 count) {
        unchecked {
            uint256 bucket = start >> 8;
            uint256 shift = start & 0xff;
            if (!(amount + shift < 257)) {
                count = LibBit.popCount(bitmap.map[bucket] >> shift);
                uint256 bucketEnd = bucket + ((amount + shift) >> 8);
                amount = (amount + shift) & 0xff;
                shift = 0;
                for (++bucket; bucket != bucketEnd; ++bucket) {
                    count += LibBit.popCount(bitmap.map[bucket]);
                }
            }
            count += LibBit.popCount(
                (bitmap.map[bucket] >> shift) << (256 - amount)
            );
        }
    }

    /// @dev Returns the index of the most significant set bit before the bit at `before`.
    /// If no set bit is found, returns `NOT_FOUND`.
    function findLastSet(Bitmap storage bitmap, uint256 before)
        internal
        view
        returns (uint256 setBitIndex)
    {
        uint256 bucket;
        uint256 bucketBits;
        /// @solidity memory-safe-assembly
        assembly {
            setBitIndex := not(0)
            bucket := shr(8, before)
            mstore(0x00, bucket)
            mstore(0x20, bitmap.slot)
            let offset := and(0xff, not(before)) // `256 - (255 & before) - 1`.
            bucketBits := shr(offset, shl(offset, sload(keccak256(0x00, 0x40))))
            if iszero(or(bucketBits, iszero(bucket))) {
                for {

                } 1 {

                } {
                    bucket := add(bucket, setBitIndex) // `sub(bucket, 1)`.
                    mstore(0x00, bucket)
                    bucketBits := sload(keccak256(0x00, 0x40))
                    if or(bucketBits, iszero(bucket)) {
                        break
                    }
                }
            }
        }
        if (bucketBits != 0) {
            setBitIndex = (bucket << 8) | LibBit.fls(bucketBits);
            /// @solidity memory-safe-assembly
            assembly {
                setBitIndex := or(setBitIndex, sub(0, gt(setBitIndex, before)))
            }
        }
    }
}

contract DN404 is
    Context,
    ERC165,
    IERC1155,
    IERC1155MetadataURI,
    IERCX,
    IERC20Metadata,
    IERC20Errors,
    Ownable
{
    using Address for address;
    using LibBitmap for LibBitmap.Bitmap;

    error InvalidQueryRange();

    // The mask of the lower 160 bits for addresses.
    uint256 private constant _BITMASK_ADDRESS = (1 << 160) - 1;
    // The `Transfer` event signature is given by:
    // `keccak256(bytes("Transfer(address,address,uint256)"))`.
    bytes32 private constant _TRANSFER_EVENT_SIGNATURE =
        0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef;

    // Mapping from accout to owned tokens
    mapping(address => LibBitmap.Bitmap) internal _owned;

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

    // Used as the URI for all token types by relying on ID substitution, e.g. https://token-cdn-domain/{id}.json
    string private _uri;

    // The next token ID to be minted.
    uint256 private _currentIndex;

    // NFT Approval
    mapping(uint256 => address) public getApproved;

    //Token balances
    mapping(address => uint256) internal _balances;

    //Token allowances
    mapping(address => mapping(address => uint256)) private _allowances;

    // Token name
    string public name;

    // Token symbol
    string public symbol;

    // Decimals for supply
    uint8 public immutable decimals;

    // Total ERC20 supply
    uint256 public immutable totalSupply;

    // Tokens Per NFT
    uint256 public immutable decimalFactor;
    uint256 public immutable tokensPerNFT;

    // Don't mint for these wallets
    mapping(address => bool) public whitelist;

    // Easy Launch - auto-whitelist first transfer which is probably the LP
    uint256 public easyLaunch = 1;

    /**
     * @dev See {_setURI}.
     */
    constructor(
        string memory uri_,
        string memory _name,
        string memory _symbol,
        uint8 _decimals,
        uint256 _totalNativeSupply,
        uint256 _tokensPerNFT
    ) Ownable(msg.sender) {
        _setURI(uri_);
        _currentIndex = _startTokenId();
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
        decimalFactor = 10**decimals;
        tokensPerNFT = _tokensPerNFT * decimalFactor;
        totalSupply = _totalNativeSupply * decimalFactor;
        whitelist[msg.sender] = true;
        _balances[msg.sender] = totalSupply;
        emit Transfer(address(0), msg.sender, totalSupply);
    }

    /** @notice Initialization function to set pairs / etc
     *  saving gas by avoiding mint / burn on unnecessary targets
     */
    function setWhitelist(address target, bool state) public virtual onlyOwner {
        whitelist[target] = state;
    }

    /**
     * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal pure virtual returns (uint256) {
        return 1;
    }

    /**
     * @dev Returns the next token ID to be minted.
     */
    function _nextTokenId() internal view returns (uint256) {
        return _currentIndex;
    }

    /**
     * @dev Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        return _nextTokenId() - _startTokenId();
    }

    /**
     * @dev Returns true if the account owns the `id` token.
     */
    function isOwnerOf(address account, uint256 id)
        public
        view
        virtual
        override
        returns (bool)
    {
        return _owned[account].get(id);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC165, IERC165)
        returns (bool)
    {
        return
            interfaceId == type(IERC1155).interfaceId ||
            interfaceId == type(IERC1155MetadataURI).interfaceId ||
            interfaceId == type(IERCX).interfaceId ||
            interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721.
            interfaceId == 0x5b5e139f || // ERC165 interface ID for ERC721Metadata.
            super.supportsInterface(interfaceId);
    }

    /**
     * @dev See {IERC1155MetadataURI-uri}.
     *
     * This implementation returns the same URI for *all* token types. It relies
     * on the token type ID substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * Clients calling this function must replace the `\{id\}` substring with the
     * actual token type ID.
     */
    function uri(uint256) public view virtual override returns (string memory) {
        return _uri;
    }

    /**
     * @dev Returns the number of tokens owned by `owner`.
     */
    function balanceOf(address owner) public view virtual returns (uint256) {
        return _balances[owner];
    }

    /**
     * @dev Returns the number of nfts owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * Requirements:
     *
     * - `start < stop`
     */
    function balanceOf(
        address owner,
        uint256 start,
        uint256 stop
    ) public view virtual returns (uint256) {
        return _owned[owner].popCount(start, stop - start);
    }

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id)
        public
        view
        virtual
        override
        returns (uint256)
    {
        if (account == address(0)) {
            revert BalanceQueryForZeroAddress();
        }
        if (_owned[account].get(id)) {
            return 1;
        } else {
            return 0;
        }
    }

    /**
     * @dev See {IERC1155-balanceOfBatch}.
     *
     * Requirements:
     *
     * - `accounts` and `ids` must have the same length.
     */
    function balanceOfBatch(address[] memory accounts, uint256[] memory ids)
        public
        view
        virtual
        override
        returns (uint256[] memory)
    {
        if (accounts.length != ids.length) {
            revert InputLengthMistmatch();
        }

        uint256[] memory batchBalances = new uint256[](accounts.length);

        for (uint256 i = 0; i < accounts.length; ++i) {
            batchBalances[i] = balanceOf(accounts[i], ids[i]);
        }

        return batchBalances;
    }

    /**
     * @dev See {IERC1155-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved)
        public
        virtual
        override
    {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        if (from == _msgSender() || isApprovedForAll(from, _msgSender())) {
            _safeTransferFrom(from, to, id, amount, data, true);
        } else {
            revert TransferCallerNotOwnerNorApproved();
        }
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        if (!(from == _msgSender() || isApprovedForAll(from, _msgSender()))) {
            revert TransferCallerNotOwnerNorApproved();
        }
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

    /**
     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `amount` cannot be zero.
     * - `from` must have a balance of tokens of type `id` of at least `amount`.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data,
        bool check
    ) internal virtual {
        if (to == address(0)) {
            revert TransferToZeroAddress();
        }

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);

        _beforeTokenTransfer(operator, from, to, ids);

        if (amount == 1 && _owned[from].get(id)) {
            _owned[from].unset(id);
            _owned[to].set(id);
            _transfer(from, to, tokensPerNFT, false);
        } else {
            revert TransferFromIncorrectOwnerOrInvalidAmount();
        }

        uint256 toMasked;
        uint256 fromMasked;
        assembly {
            // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
            toMasked := and(to, _BITMASK_ADDRESS)
            fromMasked := and(from, _BITMASK_ADDRESS)
            // Emit the `Transfer` event.
            log4(
                0, // Start of data (0, since no data).
                0, // End of data (0, since no data).
                _TRANSFER_EVENT_SIGNATURE, // Signature.
                fromMasked, // `from`.
                toMasked, // `to`.
                amount // `tokenId`.
            )
        }

        emit TransferSingle(operator, from, to, id, amount);

        _afterTokenTransfer(operator, from, to, ids);

        if (check)
            _doSafeTransferAcceptanceCheck(
                operator,
                from,
                to,
                id,
                amount,
                data
            );
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_safeTransferFrom}.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        if (ids.length != amounts.length) {
            revert InputLengthMistmatch();
        }

        if (to == address(0)) {
            revert TransferToZeroAddress();
        }
        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids);

        for (uint256 i = 0; i < ids.length; ++i) {
            uint256 id = ids[i];
            uint256 amount = amounts[i];

            if (amount == 1 && _owned[from].get(id)) {
                _owned[from].unset(id);
                _owned[to].set(id);
            } else {
                revert TransferFromIncorrectOwnerOrInvalidAmount();
            }
        }
        _transfer(from, to, tokensPerNFT * ids.length, false);

        uint256 toMasked;
        uint256 fromMasked;
        uint256 end = ids.length + 1;

        // Use assembly to loop and emit the `Transfer` event for gas savings.
        // The duplicated `log4` removes an extra check and reduces stack juggling.
        // The assembly, together with the surrounding Solidity code, have been
        // delicately arranged to nudge the compiler into producing optimized opcodes.
        assembly {
            // Mask `to` to the lower 160 bits, in case the upper bits somehow aren't clean.
            fromMasked := and(from, _BITMASK_ADDRESS)
            toMasked := and(to, _BITMASK_ADDRESS)
            // Emit the `Transfer` event.
            log4(
                0, // Start of data (0, since no data).
                0, // End of data (0, since no data).
                _TRANSFER_EVENT_SIGNATURE, // Signature.
                fromMasked, // `from`.
                toMasked, // `to`.
                mload(add(ids, 0x20)) // `tokenId`.
            )

            // The `iszero(eq(,))` check ensures that large values of `quantity`
            // that overflows uint256 will make the loop run out of gas.
            // The compiler will optimize the `iszero` away for performance.
            for {
                let arrayId := 2
            } iszero(eq(arrayId, end)) {
                arrayId := add(arrayId, 1)
            } {
                // Emit the `Transfer` event. Similar to above.
                log4(
                    0,
                    0,
                    _TRANSFER_EVENT_SIGNATURE,
                    fromMasked,
                    toMasked,
                    mload(add(ids, mul(0x20, arrayId)))
                )
            }
        }

        emit TransferBatch(operator, from, to, ids, amounts);

        _afterTokenTransfer(operator, from, to, ids);

        _doSafeBatchTransferAcceptanceCheck(
            operator,
            from,
            to,
            ids,
            amounts,
            data
        );
    }

    /**
     * @dev Sets a new URI for all token types, by relying on the token type ID
     * substitution mechanism
     * https://eips.ethereum.org/EIPS/eip-1155#metadata[defined in the EIP].
     *
     * By this mechanism, any occurrence of the `\{id\}` substring in either the
     * URI or any of the amounts in the JSON file at said URI will be replaced by
     * clients with the token type ID.
     *
     * For example, the `https://token-cdn-domain/\{id\}.json` URI would be
     * interpreted by clients as
     * `https://token-cdn-domain/000000000000000000000000000000000000000000000000000000000004cce0.json`
     * for token type ID 0x4cce0.
     *
     * See {uri}.
     *
     * Because these URIs cannot be meaningfully represented by the {URI} event,
     * this function emits no events.
     */
    function _setURI(string memory newuri) internal virtual {
        _uri = newuri;
    }

    function _mint(address to, uint256 amount) internal virtual {
        _mint(to, amount, "");
    }

    /**
     * @dev Creates `amount` tokens, and assigns them to `to`.
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `amount` cannot be zero.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        (uint256[] memory ids, uint256[] memory amounts) = _mintWithoutCheck(
            to,
            amount
        );

        uint256 end = _currentIndex;
        _doSafeBatchTransferAcceptanceCheck(
            _msgSender(),
            address(0),
            to,
            ids,
            amounts,
            data
        );
        if (_currentIndex != end) revert();
    }

    function _mintWithoutCheck(address to, uint256 amount)
        internal
        virtual
        returns (uint256[] memory ids, uint256[] memory amounts)
    {
        if (to == address(0)) {
            revert MintToZeroAddress();
        }
        if (amount == 0) {
            revert MintZeroQuantity();
        }

        address operator = _msgSender();

        ids = new uint256[](amount);
        amounts = new uint256[](amount);
        uint256 startTokenId = _nextTokenId();

        unchecked {
            require(type(uint256).max - amount >= startTokenId);
            for (uint256 i = 0; i < amount; i++) {
                ids[i] = startTokenId + i;
                amounts[i] = 1;
            }
        }

        _beforeTokenTransfer(operator, address(0), to, ids);

        _owned[to].setBatch(startTokenId, amount);
        _currentIndex += amount;

        uint256 toMasked;
        uint256 end = startTokenId + amount;

        assembly {
            toMasked := and(to, _BITMASK_ADDRESS)
            log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, startTokenId)

            for {
                let tokenId := add(startTokenId, 1)
            } iszero(eq(tokenId, end)) {
                tokenId := add(tokenId, 1)
            } {
                log4(0, 0, _TRANSFER_EVENT_SIGNATURE, 0, toMasked, tokenId)
            }
        }

        emit TransferBatch(operator, address(0), to, ids, amounts);

        _afterTokenTransfer(operator, address(0), to, ids);
    }

    /**
     * @dev Destroys token of token type `id` from `from`
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have the token of token type `id`.
     */
    function _burn(address from, uint256 id) internal virtual {
        if (from == address(0)) {
            revert BurnFromZeroAddress();
        }

        address operator = _msgSender();
        uint256[] memory ids = _asSingletonArray(id);

        _beforeTokenTransfer(operator, from, address(0), ids);

        if (!_owned[from].get(id)) {
            revert BurnFromNonOnwerAddress();
        }

        _owned[from].unset(id);

        uint256 fromMasked;
        assembly {
            fromMasked := and(from, _BITMASK_ADDRESS)
            log4(0, 0, _TRANSFER_EVENT_SIGNATURE, fromMasked, 0, id)
        }

        emit TransferSingle(operator, from, address(0), id, 1);

        _afterTokenTransfer(operator, from, address(0), ids);
    }

    /**
     * @dev Destroys tokens of token types in `ids` from `from`
     *
     * Emits a {TransferBatch} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have the token of token types in `ids`.
     */
    function _burnBatch(address from, uint256[] memory ids) internal virtual {
        if (from == address(0)) {
            revert BurnFromZeroAddress();
        }

        address operator = _msgSender();

        uint256[] memory amounts = new uint256[](ids.length);

        _beforeTokenTransfer(operator, from, address(0), ids);

        unchecked {
            for (uint256 i = 0; i < ids.length; i++) {
                amounts[i] = 1;
                uint256 id = ids[i];
                if (!_owned[from].get(id)) {
                    revert BurnFromNonOnwerAddress();
                }
                _owned[from].unset(id);
            }
        }

        uint256 fromMasked;
        uint256 end = ids.length + 1;

        assembly {
            fromMasked := and(from, _BITMASK_ADDRESS)
            log4(
                0,
                0,
                _TRANSFER_EVENT_SIGNATURE,
                fromMasked,
                0,
                mload(add(ids, 0x20))
            )

            for {
                let arrayId := 2
            } iszero(eq(arrayId, end)) {
                arrayId := add(arrayId, 1)
            } {
                log4(
                    0,
                    0,
                    _TRANSFER_EVENT_SIGNATURE,
                    fromMasked,
                    0,
                    mload(add(ids, mul(0x20, arrayId)))
                )
            }
        }

        emit TransferBatch(operator, from, address(0), ids, amounts);

        _afterTokenTransfer(operator, from, address(0), ids);
    }

    function _burnBatch(address from, uint256 amount) internal virtual {
        if (from == address(0)) {
            revert BurnFromZeroAddress();
        }

        address operator = _msgSender();

        uint256 searchFrom = _nextTokenId();

        uint256[] memory amounts = new uint256[](amount);
        uint256[] memory ids = new uint256[](amount);

        unchecked {
            for (uint256 i = 0; i < amount; i++) {
                amounts[i] = 1;
                uint256 id = _owned[from].findLastSet(searchFrom);
                ids[i] = id;
                _owned[from].unset(id);
                searchFrom = id;
            }
        }

        //technically after, but we didn't have the IDs then
        _beforeTokenTransfer(operator, from, address(0), ids);

        uint256 fromMasked;
        uint256 end = amount + 1;

        assembly {
            fromMasked := and(from, _BITMASK_ADDRESS)
            log4(
                0,
                0,
                _TRANSFER_EVENT_SIGNATURE,
                fromMasked,
                0,
                mload(add(ids, 0x20))
            )

            for {
                let arrayId := 2
            } iszero(eq(arrayId, end)) {
                arrayId := add(arrayId, 1)
            } {
                log4(
                    0,
                    0,
                    _TRANSFER_EVENT_SIGNATURE,
                    fromMasked,
                    0,
                    mload(add(ids, mul(0x20, arrayId)))
                )
            }
        }

        if (amount == 1)
            emit TransferSingle(operator, from, address(0), ids[0], 1);
        else emit TransferBatch(operator, from, address(0), ids, amounts);

        _afterTokenTransfer(operator, from, address(0), ids);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits an {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC1155: setting approval status for self");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `ids` and `amounts` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids
    ) internal virtual {}

    /**
     * @dev Hook that is called after any token transfer. This includes minting
     * and burning, as well as batched variants.
     *
     * The same hook is called on both single and batched variants. For single
     * transfers, the length of the `id` and `amount` arrays will be 1.
     *
     * Calling conditions (for each `id` and `amount` pair):
     *
     * - When `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * of token type `id` will be  transferred to `to`.
     * - When `from` is zero, `amount` tokens of token type `id` will be minted
     * for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens of token type `id`
     * will be burned.
     * - `from` and `to` are never both zero.
     * - `ids` and `amounts` have the same, non-zero length.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids
    ) internal virtual {}

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            if (IERC165(to).supportsInterface(type(IERC1155).interfaceId)) {
                try
                    IERC1155Receiver(to).onERC1155Received(
                        operator,
                        from,
                        id,
                        amount,
                        data
                    )
                returns (bytes4 response) {
                    if (
                        response != IERC1155Receiver.onERC1155Received.selector
                    ) {
                        revert TransferToNonERC1155ReceiverImplementer();
                    }
                } catch Error(string memory reason) {
                    revert(reason);
                } catch {
                    revert TransferToNonERC1155ReceiverImplementer();
                }
            } else {
                try
                    ERC721Receiver(to).onERC721Received(
                        operator,
                        from,
                        id,
                        data
                    )
                returns (bytes4 response) {
                    if (response != ERC721Receiver.onERC721Received.selector) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } catch Error(string memory reason) {
                    revert(reason);
                } catch {
                    revert TransferToNonERC721ReceiverImplementer();
                }
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try
                IERC1155Receiver(to).onERC1155BatchReceived(
                    operator,
                    from,
                    ids,
                    amounts,
                    data
                )
            returns (bytes4 response) {
                if (
                    response != IERC1155Receiver.onERC1155BatchReceived.selector
                ) {
                    revert TransferToNonERC1155ReceiverImplementer();
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert TransferToNonERC1155ReceiverImplementer();
            }
        }
    }

    function _asSingletonArray(uint256 element)
        private
        pure
        returns (uint256[] memory array)
    {
        array = new uint256[](1);
        array[0] = element;
    }

    function transfer(address to, uint256 value) public virtual returns (bool) {
        address owner = msg.sender;
        _transfer(owner, to, value, true);
        return true;
    }

    function allowance(address owner, address spender)
        public
        view
        virtual
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    function approve(address spender, uint256 value)
        public
        virtual
        returns (bool)
    {
        address owner = msg.sender;
        if (value < _nextTokenId() && value > 0) {
            if (!isOwnerOf(owner, value)) {
                revert ERC20InvalidSender(owner);
            }

            getApproved[value] = spender;

            emit Approval(owner, spender, value);
        } else {
            _approve(owner, spender, value);
        }
        return true;
    }

    /// @notice Function for mixed transfers
    /// @dev This function assumes id / native if amount less than or equal to current max id
    function transferFrom(
        address from,
        address to,
        uint256 value
    ) public virtual returns (bool) {
        if (value < _nextTokenId()) {
            if (!_owned[from].get(value)) {
                revert ERC20InvalidSpender(from);
            }

            if (
                msg.sender != from &&
                !isApprovedForAll(from, msg.sender) &&
                msg.sender != getApproved[value]
            ) {
                revert ERC20InvalidSpender(msg.sender);
            }

            _transfer(from, to, tokensPerNFT, false);

            delete getApproved[value];

            _safeTransferFrom(from, to, value, 1, "", false);
        } else {
            _spendAllowance(from, msg.sender, value);
            _transfer(from, to, value, true);
        }
        return true;
    }

    function _transfer(
        address from,
        address to,
        uint256 value,
        bool mint
    ) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value, mint);
    }

    function _update(
        address from,
        address to,
        uint256 value,
        bool mint
    ) internal virtual {
        uint256 fromBalance = _balances[from];
        uint256 toBalance = _balances[to];
        if (fromBalance < value) {
            revert ERC20InsufficientBalance(from, fromBalance, value);
        }

        unchecked {
            // Overflow not possible: value <= fromBalance <= totalSupply.
            _balances[from] = fromBalance - value;

            // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
            _balances[to] = toBalance + value;
        }

        emit Transfer(from, to, value);

        if (mint) {
            // Skip burn for certain addresses to save gas
            bool wlf = whitelist[from];
            if (!wlf) {
                uint256 tokens_to_burn = (fromBalance / tokensPerNFT) -
                    ((fromBalance - value) / tokensPerNFT);
                if (tokens_to_burn > 0) _burnBatch(from, tokens_to_burn);
            }

            // Skip minting for certain addresses to save gas
            if (!whitelist[to]) {
                if (easyLaunch == 1 && wlf && from == owner()) {
                    //auto-initialize first (assumed) LP
                    whitelist[to] = true;
                    easyLaunch = 2;
                } else {
                    uint256 tokens_to_mint = ((toBalance + value) /
                        tokensPerNFT) - (toBalance / tokensPerNFT);
                    if (tokens_to_mint > 0)
                        _mintWithoutCheck(to, tokens_to_mint);
                }
            }
        }
    }

    function _approve(
        address owner,
        address spender,
        uint256 value
    ) internal {
        _approve(owner, spender, value, true);
    }

    function _approve(
        address owner,
        address spender,
        uint256 value,
        bool emitEvent
    ) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    function _spendAllowance(
        address owner,
        address spender,
        uint256 value
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(
                    spender,
                    currentAllowance,
                    value
                );
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`,
     * in the range [`start`, `stop`)
     * (i.e. `start <= tokenId < stop`).
     *
     * This function allows for tokens to be queried if the collection
     * grows too big for a single call of {ERC1155DelataQueryable-tokensOfOwner}.
     *
     * Requirements:
     *
     * - `start < stop`
     */
    function tokensOfOwnerIn(
        address owner,
        uint256 start,
        uint256 stop
    ) public view virtual returns (uint256[] memory) {
        unchecked {
            if (start >= stop) revert InvalidQueryRange();

            // Set `start = max(start, _startTokenId())`.
            if (start < _startTokenId()) {
                start = _startTokenId();
            }

            // Set `stop = min(stop, stopLimit)`.
            uint256 stopLimit = _nextTokenId();
            if (stop > stopLimit) {
                stop = stopLimit;
            }

            uint256 tokenIdsLength;
            if (start < stop) {
                tokenIdsLength = balanceOf(owner, start, stop);
            } else {
                tokenIdsLength = 0;
            }

            uint256[] memory tokenIds = new uint256[](tokenIdsLength);

            LibBitmap.Bitmap storage bmap = _owned[owner];

            for (
                (uint256 i, uint256 tokenIdsIdx) = (start, 0);
                tokenIdsIdx != tokenIdsLength;
                ++i
            ) {
                if (bmap.get(i)) {
                    tokenIds[tokenIdsIdx++] = i;
                }
            }
            return tokenIds;
        }
    }

    /**
     * @dev Returns an array of token IDs owned by `owner`.
     *
     * This function scans the ownership mapping and is O(`totalSupply`) in complexity.
     * It is meant to be called off-chain.
     *
     * See {ERC1155DeltaQueryable-tokensOfOwnerIn} for splitting the scan into
     * multiple smaller scans if the collection is large enough to cause
     * an out-of-gas error (10K collections should be fine).
     */
    function tokensOfOwner(address owner)
        public
        view
        virtual
        returns (uint256[] memory)
    {
        if (_totalMinted() == 0) {
            return new uint256[](0);
        }
        return tokensOfOwnerIn(owner, _startTokenId(), _nextTokenId());
    }
}

contract Fidn404 is DN404 {
    using Strings for uint256;
    string public dataURI;
    string public baseTokenURI;

    uint8 private constant _decimals = 18;
    uint256 private constant _totalTokens = 10000;
    uint256 private constant _tokensPerNFT = 1;
    string private constant _name = "Fidn404";
    string private constant _ticker = "Fidn404";

    // Snipe reduction tools
    uint256 public maxWallet;
    bool public transferDelay = true;
    mapping(address => uint256) private delayTimer;

    constructor()
        DN404("", _name, _ticker, _decimals, _totalTokens, _tokensPerNFT)
    {
        dataURI = "https://i.ibb.co/";
        maxWallet = (_totalTokens * 10**_decimals);
    }

    function _afterTokenTransfer(
        address operator,
        address from,
        address to,
        uint256[] memory ids
    ) internal override {
        if (!whitelist[to]) {
            require(
                _balances[to] <= maxWallet,
                "Transfer exceeds maximum wallet"
            );
            if (transferDelay) {
                require(
                    delayTimer[tx.origin] < block.number,
                    "Only one transfer per block allowed."
                );
                delayTimer[tx.origin] = block.number;

                require(
                    address(to).code.length == 0 &&
                        address(tx.origin).code.length == 0,
                    "Contract trading restricted at launch"
                );
            }
        }

        super._afterTokenTransfer(operator, from, to, ids);
    }

    function toggleDelay() external onlyOwner {
        transferDelay = !transferDelay;
    }

    function setMaxWallet(uint256 percent) external onlyOwner {
        maxWallet = (totalSupply * percent) / 100;
    }

    function setDataURI(string memory _dataURI) public onlyOwner {
        dataURI = _dataURI;
    }

    function setTokenURI(string memory _tokenURI) public onlyOwner {
        baseTokenURI = _tokenURI;
    }

    function setURI(string memory newuri) external onlyOwner {
        _setURI(newuri);
    }

    function tokenURI(uint256 id) public view returns (string memory) {
        if (id >= _nextTokenId()) revert InputLengthMistmatch();

        if (bytes(super.uri(id)).length > 0) return super.uri(id);
        if (bytes(baseTokenURI).length > 0)
            return string(abi.encodePacked(baseTokenURI, id.toString()));
        else {
            uint8 seed = uint8(bytes1(keccak256(abi.encodePacked(id))));

            string memory image;
            string memory color;
            string memory description;

            if (seed <= 63) {
                image = "SNb4zN0/FIDN404.png";
                color = "Diamond";
                description = "Legendary NFTs powered by ERC1155. The Diamond NFTs are meticulously mined by industry elites and crafted with unparalleled precision, representing the zenith of luxury and digital artistry.";
            } else if (seed <= 127) {
                image = "SNb4zN0/FIDN404.png";
                color = "Gold";
                description = "Prestigious NFTs powered by ERC1155. The gold NFTs are carefully mined by expert collectors and meticulously crafted with golden excellence, symbolizing the pinnacle of digital rarity and exclusivity.";
            } else if (seed <= 191) {
                image = "SNb4zN0/FIDN404.png";
                color = "Silver";
                description = "Refined NFTs powered by ERC1155. The silver NFTs are mined by seasoned enthusiasts, adding an extra layer of sophistication to your portfolio.";
            } else if (seed <= 255) {
                image = "SNb4zN0/FIDN404.png";
                color = "Bronze";
                description = "Entry level NFTs powered by ERC1155. The silver NFTs are mined by aspiring collectors and meticulously crafted for accessibility.";
            }

            string memory jsonPreImage = string(
                abi.encodePacked(
                    '{"name": "MINER #',
                    id.toString(),
                    '","description":"',
                    description,
                    '","external_url":"https://miner.build","image":"',
                    dataURI,
                    image
                )
            );
            return
                string(
                    abi.encodePacked(
                        "data:application/json;utf8,",
                        jsonPreImage,
                        '","attributes":[{"trait_type":"Color","value":"',
                        color,
                        '"}]}'
                    )
                );
        }
    }

    function uri(uint256 id) public view override returns (string memory) {
        return tokenURI(id);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"BurnFromNonOnwerAddress","type":"error"},{"inputs":[],"name":"BurnFromZeroAddress","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[],"name":"InputLengthMistmatch","type":"error"},{"inputs":[],"name":"InvalidQueryRange","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwnerOrInvalidAmount","type":"error"},{"inputs":[],"name":"TransferToNonERC1155ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","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":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"indexed":false,"internalType":"uint256[]","name":"values","type":"uint256[]"}],"name":"TransferBatch","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TransferSingle","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"value","type":"string"},{"indexed":true,"internalType":"uint256","name":"id","type":"uint256"}],"name":"URI","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"}],"name":"balanceOfBatch","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dataURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimalFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"easyLaunch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"}],"name":"isOwnerOf","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxWallet","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":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256[]","name":"ids","type":"uint256[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"safeBatchTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"id","type":"uint256"},{"internalType":"uint256","name":"amount","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":"_dataURI","type":"string"}],"name":"setDataURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"percent","type":"uint256"}],"name":"setMaxWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"setTokenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"newuri","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"setWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleDelay","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"tokensOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"start","type":"uint256"},{"internalType":"uint256","name":"stop","type":"uint256"}],"name":"tokensOfOwnerIn","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokensPerNFT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"transferDelay","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelist","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

6101006040526001600b819055600f805460ff1916909117905534801562000025575f80fd5b5060408051602080820183525f825282518084018452600780825266119a591b8d0c0d60ca1b82840181905285518087019096529085529184019190915290916012612710600133806200009257604051631e4fbdf760e01b81525f600482015260240160405180910390fd5b6200009d81620001c9565b50620000a98662000218565b60016004556008620000bc8682620002c8565b506009620000cb8582620002c8565b5060ff83166080819052620000e290600a620004a3565b60c0819052620000f39082620004ba565b60e05260c051620001059083620004ba565b60a0819052335f818152600a60209081526040808320805460ff191660011790556006825280832085905551938452919290917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a35050505050506040518060400160405280601181526020017068747470733a2f2f692e6962622e636f2f60781b815250600c9081620001a39190620002c8565b50620001b26012600a620004a3565b620001c090612710620004ba565b600e55620004d4565b5f80546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b6003620002268282620002c8565b5050565b634e487b7160e01b5f52604160045260245ffd5b600181811c908216806200025357607f821691505b6020821081036200027257634e487b7160e01b5f52602260045260245ffd5b50919050565b601f821115620002c357805f5260205f20601f840160051c810160208510156200029f5750805b601f840160051c820191505b81811015620002c0575f8155600101620002ab565b50505b505050565b81516001600160401b03811115620002e457620002e46200022a565b620002fc81620002f584546200023e565b8462000278565b602080601f83116001811462000332575f84156200031a5750858301515b5f19600386901b1c1916600185901b1785556200038c565b5f85815260208120601f198616915b82811015620003625788860151825594840194600190910190840162000341565b50858210156200038057878501515f19600388901b60f8161c191681555b505060018460011b0185555b505050505050565b634e487b7160e01b5f52601160045260245ffd5b600181815b80851115620003e857815f1904821115620003cc57620003cc62000394565b80851615620003da57918102915b93841c9390800290620003ad565b509250929050565b5f8262000400575060016200049d565b816200040e57505f6200049d565b8160018114620004275760028114620004325762000452565b60019150506200049d565b60ff84111562000446576200044662000394565b50506001821b6200049d565b5060208310610133831016604e8410600b841016171562000477575081810a6200049d565b620004838383620003a8565b805f190482111562000499576200049962000394565b0290505b92915050565b5f620004b360ff841683620003f0565b9392505050565b80820281158282048414176200049d576200049d62000394565b60805160a05160c05160e051613790620005405f395f8181610414015281816109a50152818161131e0152818161165701528181611bed01528181611c2501528181611ce50152611d0c01525f61044e01525f818161032d0152610bdf01525f6103a001526137905ff3fe608060405234801561000f575f80fd5b506004361061023e575f3560e01c806370a0823111610135578063c5b8f772116100b4578063e985e9c511610079578063e985e9c5146105a8578063f242432a146105e3578063f28ca1dd146105f6578063f2fde38b146105fe578063f8b45b0514610611575f80fd5b8063c5b8f7721461052f578063c87b56dd14610542578063d547cfb714610555578063dd62ed3e1461055d578063e0df5b6f14610595575f80fd5b806399a2557a116100fa57806399a2557a146104cb5780639b19251a146104de578063a014e6e214610500578063a22cb46514610509578063a9059cbb1461051c575f80fd5b806370a0823114610470578063715018a6146104985780638462151c146104a05780638da5cb5b146104b357806395d89b41146104c3575f80fd5b806323b872dd116101c15780634eabf2c6116101865780634eabf2c6146103f457806353d6fd59146103fc5780635afcc2f51461040f5780635d0044ca146104365780636d6a6a4d14610449575f80fd5b806323b872dd146103625780632d760d57146103755780632eb2c2d614610388578063313ce5671461039b5780634e1273f4146103d4575f80fd5b8063095ea7b311610207578063095ea7b3146102f55780630a702e8d146103085780630e89341c1461031557806318160ddd1461032857806318d217c31461034f575f80fd5b8062fdd58e1461024257806301ffc9a71461026857806302fe53051461028b57806306fdde03146102a0578063081812fc146102b5575b5f80fd5b61025561025036600461296a565b61061a565b6040519081526020015b60405180910390f35b61027b6102763660046129a7565b610686565b604051901515815260200161025f565b61029e610299366004612a5c565b610726565b005b6102a861073a565b60405161025f9190612aed565b6102dd6102c3366004612aff565b60056020525f90815260409020546001600160a01b031681565b6040516001600160a01b03909116815260200161025f565b61027b61030336600461296a565b6107c6565b600f5461027b9060ff1681565b6102a8610323366004612aff565b610896565b6102557f000000000000000000000000000000000000000000000000000000000000000081565b61029e61035d366004612a5c565b6108a1565b61027b610370366004612b16565b6108b9565b610255610383366004612b4f565b610a21565b61029e610396366004612c32565b610a56565b6103c27f000000000000000000000000000000000000000000000000000000000000000081565b60405160ff909116815260200161025f565b6103e76103e2366004612cd4565b610aa3565b60405161025f9190612dd2565b61029e610b81565b61029e61040a366004612df1565b610b9d565b6102557f000000000000000000000000000000000000000000000000000000000000000081565b61029e610444366004612aff565b610bcf565b6102557f000000000000000000000000000000000000000000000000000000000000000081565b61025561047e366004612e26565b6001600160a01b03165f9081526006602052604090205490565b61029e610c13565b6103e76104ae366004612e26565b610c26565b5f546001600160a01b03166102dd565b6102a8610c57565b6103e76104d9366004612b4f565b610c64565b61027b6104ec366004612e26565b600a6020525f908152604090205460ff1681565b610255600b5481565b61029e610517366004612df1565b610d90565b61027b61052a36600461296a565b610d9b565b61027b61053d36600461296a565b610daa565b6102a8610550366004612aff565b610ddf565b6102a86110e8565b61025561056b366004612e3f565b6001600160a01b039182165f90815260076020908152604080832093909416825291909152205490565b61029e6105a3366004612a5c565b6110f5565b61027b6105b6366004612e3f565b6001600160a01b039182165f90815260026020908152604080832093909416825291909152205460ff1690565b61029e6105f1366004612e70565b611109565b6102a8611157565b61029e61060c366004612e26565b611164565b610255600e5481565b5f6001600160a01b038316610642576040516323d3ad8160e21b815260040160405180910390fd5b6001600160a01b0383165f908152600160208181526040808420600887901c85529091529091205460ff84161c161561067d57506001610680565b505f5b92915050565b5f6001600160e01b03198216636cdb3d1360e11b14806106b657506001600160e01b031982166303a24d0760e21b145b806106d157506001600160e01b031982166362dc7bb960e11b145b806106ec57506380ac58cd60e01b6001600160e01b03198316145b806107075750635b5e139f60e01b6001600160e01b03198316145b8061068057506301ffc9a760e01b6001600160e01b0319831614610680565b61072e61119e565b610737816111ca565b50565b6008805461074790612ecf565b80601f016020809104026020016040519081016040528092919081815260200182805461077390612ecf565b80156107be5780601f10610795576101008083540402835291602001916107be565b820191905f5260205f20905b8154815290600101906020018083116107a157829003601f168201915b505050505081565b5f336107d160045490565b831080156107de57505f83115b15610881576107ed8184610daa565b61081a57604051634b637e8f60e11b81526001600160a01b03821660048201526024015b60405180910390fd5b5f8381526005602090815260409182902080546001600160a01b0319166001600160a01b038881169182179092559251868152908416917f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a361088c565b61088c8185856111d6565b5060019392505050565b606061068082610ddf565b6108a961119e565b600c6108b58282612f4b565b5050565b5f6108c360045490565b821015610a09576001600160a01b0384165f908152600160208181526040808420600887901c85529091529091205460ff84161c1661092057604051634a1406b160e11b81526001600160a01b0385166004820152602401610811565b336001600160a01b0385161480159061095c57506001600160a01b0384165f90815260026020908152604080832033845290915290205460ff16155b801561097e57505f828152600560205260409020546001600160a01b03163314155b1561099e57604051634a1406b160e11b8152336004820152602401610811565b6109ca84847f00000000000000000000000000000000000000000000000000000000000000005f6111e8565b5f82815260056020908152604080832080546001600160a01b031916905580519182019052818152610a049186918691869160019161124c565b61088c565b610a1484338461140f565b61088c84848460016111e8565b5f610a4e83610a30818561301a565b6001600160a01b0387165f9081526001602052604090209190611484565b949350505050565b6001600160a01b038516331480610a725750610a7285336105b6565b610a8f57604051632ce44b5f60e11b815260040160405180910390fd5b610a9c8585858585611522565b5050505050565b60608151835114610ac757604051637801f4e960e01b815260040160405180910390fd5b5f83516001600160401b03811115610ae157610ae16129c2565b604051908082528060200260200182016040528015610b0a578160200160208202803683370190505b5090505f5b8451811015610b7957610b54858281518110610b2d57610b2d61302d565b6020026020010151858381518110610b4757610b4761302d565b602002602001015161061a565b828281518110610b6657610b6661302d565b6020908102919091010152600101610b0f565b509392505050565b610b8961119e565b600f805460ff19811660ff90911615179055565b610ba561119e565b6001600160a01b03919091165f908152600a60205260409020805460ff1916911515919091179055565b610bd761119e565b6064610c03827f0000000000000000000000000000000000000000000000000000000000000000613041565b610c0d919061306c565b600e5550565b610c1b61119e565b610c245f611772565b565b6060610c306117c1565b5f03610c49575050604080515f81526020810190915290565b610680826001600454610c64565b6009805461074790612ecf565b6060818310610c8657604051631960ccad60e11b815260040160405180910390fd5b6001831015610c9457600192505b5f610c9e60045490565b905080831115610cac578092505b5f83851015610cc757610cc0868686610a21565b9050610cca565b505f5b5f816001600160401b03811115610ce357610ce36129c2565b604051908082528060200260200182016040528015610d0c578160200160208202803683370190505b506001600160a01b0388165f90815260016020526040812091925087905b848114610d8257600882901c5f9081526020849052604090205460ff83161c60011615610d775781848280600101935081518110610d6a57610d6a61302d565b6020026020010181815250505b816001019150610d2a565b509198975050505050505050565b6108b53383836117d6565b5f3361088c81858560016111e8565b6001600160a01b0382165f908152600160208181526040808420600886901c855290915282205460ff84161c165b9392505050565b6060610dea60045490565b8210610e0957604051637801f4e960e01b815260040160405180910390fd5b5f610e13836118b5565b511115610e2357610680826118b5565b5f600d8054610e3190612ecf565b90501115610e6b57600d610e4483611947565b604051602001610e559291906130ee565b6040516020818303038152906040529050919050565b5f82604051602001610e7f91815260200190565b6040516020818303038152906040528051906020012060f81c90506060806060603f8460ff1611610f1a5760405180604001604052806013815260200172534e62347a4e302f4649444e3430342e706e6760681b815250925060405180604001604052806007815260200166111a585b5bdb9960ca1b81525091506040518060e0016040528060be81526020016135d560be91399050611083565b607f8460ff1611610f935760405180604001604052806013815260200172534e62347a4e302f4649444e3430342e706e6760681b81525092506040518060400160405280600481526020016311dbdb1960e21b815250915060405180610100016040528060c8815260200161369360c891399050611083565b60bf8460ff161161100d5760405180604001604052806013815260200172534e62347a4e302f4649444e3430342e706e6760681b81525092506040518060400160405280600681526020016529b4b63b32b960d11b81525091506040518060c00160405280608e8152602001613547608e91399050611083565b60ff8460ff16116110835760405180604001604052806013815260200172534e62347a4e302f4649444e3430342e706e6760681b81525092506040518060400160405280600681526020016542726f6e7a6560d01b81525091506040518060c00160405280608181526020016134a66081913990505b5f61108d87611947565b82600c866040516020016110a49493929190613112565b604051602081830303815290604052905080836040516020016110c89291906131dd565b60405160208183030381529060405295505050505050919050565b919050565b600d805461074790612ecf565b6110fd61119e565b600d6108b58282612f4b565b6001600160a01b038516331480611125575061112585336105b6565b1561113e576111398585858585600161124c565b610a9c565b604051632ce44b5f60e11b815260040160405180910390fd5b600c805461074790612ecf565b61116c61119e565b6001600160a01b03811661119557604051631e4fbdf760e01b81525f6004820152602401610811565b61073781611772565b5f546001600160a01b03163314610c245760405163118cdaa760e01b8152336004820152602401610811565b60036108b58282612f4b565b6111e38383836001611a43565b505050565b6001600160a01b03841661121157604051634b637e8f60e11b81525f6004820152602401610811565b6001600160a01b03831661123a5760405163ec442f0560e01b81525f6004820152602401610811565b61124684848484611b15565b50505050565b6001600160a01b03851661127357604051633a954ecd60e21b815260040160405180910390fd5b335f61127e86611d67565b90508460011480156112ba57506001600160a01b0388165f90815260016020818152604080842060088b901c85529091529091205460ff88161c165b15611348576001600160a01b038881165f90815260016020818152604080842060088c901c808652908352818520805460ff8e1686901b8019909116909155958d1685529282528084209284529190528120805490921790915561134390899089907f0000000000000000000000000000000000000000000000000000000000000000906111e8565b611361565b6040516337dbad3d60e01b815260040160405180910390fd5b6001600160a01b038781169089168682825f805160206135278339815191525f80a4886001600160a01b03168a6001600160a01b0316856001600160a01b03167fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f628b8b6040516113db929190918252602082015260400190565b60405180910390a46113ef848b8b86611dad565b841561140357611403848b8b8b8b8b611f30565b50505050505050505050565b6001600160a01b038381165f908152600760209081526040808320938616835292905220545f198114611246578181101561147657604051637dc7a0d960e11b81526001600160a01b03841660048201526024810182905260448101839052606401610811565b61124684848484035f611a43565b5f600883901c60ff8416610101848201106114f6575f828152602087905260409020546114b290821c61219a565b930160ff811693925060018201915f9160081c015b8083146114f4575f838152602088905260409020546114e59061219a565b840193508260010192506114c7565b505b5f8281526020879052604090205461151690821c6101008690031b61219a565b90920195945050505050565b815183511461154457604051637801f4e960e01b815260040160405180910390fd5b6001600160a01b03841661156b57604051633a954ecd60e21b815260040160405180910390fd5b335f5b845181101561164d575f85828151811061158a5761158a61302d565b602002602001015190505f8583815181106115a7576115a761302d565b602002602001015190508060011480156115eb57506001600160a01b0389165f908152600160208181526040808420600887901c85529091529091205460ff84161c165b1561134857506001600160a01b038881165f908152600160208181526040808420600887901c808652908352818520805460ff90981685901b80199098169055948c16845282825280842094845293905291902080549092179091550161156e565b50611686868686517f00000000000000000000000000000000000000000000000000000000000000006116809190613041565b5f6111e8565b5f805f865160016116979190613286565b90506001600160a01b03891691506001600160a01b0388169250602087015183835f805160206135278339815191525f80a460025b8181146116f5578060200288015184845f805160206135278339815191525f80a46001016116cc565b50876001600160a01b0316896001600160a01b0316856001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb8a8a604051611745929190613299565b60405180910390a4611759848a8a8a611dad565b611767848a8a8a8a8a612249565b505050505050505050565b5f80546001600160a01b038381166001600160a01b0319831681178455604051919092169283917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09190a35050565b5f60016004546117d1919061301a565b905090565b816001600160a01b0316836001600160a01b0316036118495760405162461bcd60e51b815260206004820152602960248201527f455243313135353a2073657474696e6720617070726f76616c20737461747573604482015268103337b91039b2b63360b91b6064820152608401610811565b6001600160a01b038381165f81815260026020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b6060600380546118c490612ecf565b80601f01602080910402602001604051908101604052809291908181526020018280546118f090612ecf565b801561193b5780601f106119125761010080835404028352916020019161193b565b820191905f5260205f20905b81548152906001019060200180831161191e57829003601f168201915b50505050509050919050565b6060815f0361196d5750506040805180820190915260018152600360fc1b602082015290565b815f5b81156119965780611980816132c6565b915061198f9050600a8361306c565b9150611970565b5f816001600160401b038111156119af576119af6129c2565b6040519080825280601f01601f1916602001820160405280156119d9576020820181803683370190505b5090505b8415610a4e576119ee60018361301a565b91506119fb600a866132de565b611a06906030613286565b60f81b818381518110611a1b57611a1b61302d565b60200101906001600160f81b03191690815f1a905350611a3c600a8661306c565b94506119dd565b6001600160a01b038416611a6c5760405163e602df0560e01b81525f6004820152602401610811565b6001600160a01b038316611a9557604051634a1406b160e11b81525f6004820152602401610811565b6001600160a01b038085165f908152600760209081526040808320938716835292905220829055801561124657826001600160a01b0316846001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92584604051611b0791815260200190565b60405180910390a350505050565b6001600160a01b038085165f9081526006602052604080822054928616825290205483821015611b715760405163391434e360e21b81526001600160a01b03871660048201526024810183905260448101859052606401610811565b6001600160a01b038087165f81815260066020526040808220888703905592881680825290839020848801905591515f8051602061352783398151915290611bbc9088815260200190565b60405180910390a38215611d5f576001600160a01b0386165f908152600a602052604090205460ff1680611c68575f7f0000000000000000000000000000000000000000000000000000000000000000611c16878661301a565b611c20919061306c565b611c4a7f00000000000000000000000000000000000000000000000000000000000000008661306c565b611c54919061301a565b90508015611c6657611c668882612304565b505b6001600160a01b0386165f908152600a602052604090205460ff16611d5d57600b546001148015611c965750805b8015611cae57505f546001600160a01b038881169116145b15611cdf576001600160a01b0386165f908152600a60205260409020805460ff191660011790556002600b55611d5d565b5f611d0a7f00000000000000000000000000000000000000000000000000000000000000008461306c565b7f0000000000000000000000000000000000000000000000000000000000000000611d358886613286565b611d3f919061306c565b611d49919061301a565b90508015611d5b5761140387826125b3565b505b505b505050505050565b6040805160018082528183019092526060916020808301908036833701905050905081815f81518110611d9c57611d9c61302d565b602002602001018181525050919050565b6001600160a01b0382165f908152600a602052604090205460ff16611f2b57600e546001600160a01b0383165f908152600660205260409020541115611e355760405162461bcd60e51b815260206004820152601f60248201527f5472616e736665722065786365656473206d6178696d756d2077616c6c6574006044820152606401610811565b600f5460ff1615611f2b57325f908152601060205260409020544311611ea95760405162461bcd60e51b8152602060048201526024808201527f4f6e6c79206f6e65207472616e736665722070657220626c6f636b20616c6c6f6044820152633bb2b21760e11b6064820152608401610811565b325f9081526010602052604090204390556001600160a01b0382163b158015611ed15750323b155b611f2b5760405162461bcd60e51b815260206004820152602560248201527f436f6e74726163742074726164696e672072657374726963746564206174206c6044820152640c2eadcc6d60db1b6064820152608401610811565b611246565b6001600160a01b0384163b15611d5f576040516301ffc9a760e01b8152636cdb3d1360e11b60048201526001600160a01b038516906301ffc9a790602401602060405180830381865afa158015611f89573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611fad91906132f1565b156120b75760405163f23a6e6160e01b81526001600160a01b0385169063f23a6e6190611fe6908990899088908890889060040161330c565b6020604051808303815f875af1925050508015612020575060408051601f3d908101601f1916820190925261201d91810190613350565b60015b6120805761202c61336b565b806308c379a0036120655750612040613384565b8061204b5750612067565b8060405162461bcd60e51b81526004016108119190612aed565b505b604051639c05499b60e01b815260040160405180910390fd5b6001600160e01b0319811663f23a6e6160e01b146120b157604051639c05499b60e01b815260040160405180910390fd5b50611d5f565b604051630a85bd0160e11b81526001600160a01b0385169063150b7a02906120e990899089908890879060040161340c565b6020604051808303815f875af1925050508015612123575060408051601f3d908101601f1916820190925261212091810190613350565b60015b6121695761212f61336b565b806308c379a00361214e5750612143613384565b8061204b5750612150565b505b6040516368d2bf6b60e11b815260040160405180910390fd5b6001600160e01b03198116630a85bd0160e11b14611d5d576040516368d2bf6b60e11b815260040160405180910390fd5b7f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f7f5555555555555555555555555555555555555555555555555555555555555555600183901c168203600281901c7f3333333333333333333333333333333333333333333333333333333333333333908116911601600481901c01167f01010101010101010101010101010101010101010101010101010101010101010260f81c5f199190911460081b1790565b6001600160a01b0384163b15611d5f5760405163bc197c8160e01b81526001600160a01b0385169063bc197c819061228d9089908990889088908890600401613448565b6020604051808303815f875af19250505080156122c7575060408051601f3d908101601f191682019092526122c491810190613350565b60015b6122d35761202c61336b565b6001600160e01b0319811663bc197c8160e01b14611d5d57604051639c05499b60e01b815260040160405180910390fd5b6001600160a01b03821661232b5760405163b817eee760e01b815260040160405180910390fd5b60045433905f836001600160401b03811115612349576123496129c2565b604051908082528060200260200182016040528015612372578160200160208202803683370190505b5090505f846001600160401b0381111561238e5761238e6129c2565b6040519080825280602002602001820160405280156123b7578160200160208202803683370190505b5090505f5b858110156124675760018382815181106123d8576123d861302d565b6020908102919091018101919091526001600160a01b0388165f90815260019091526040812061240890866127f1565b90508083838151811061241d5761241d61302d565b6020908102919091018101919091526001600160a01b0389165f90815260018083526040808320600886901c8452909352919020805460ff841683901b19169055909450016123bc565b505f80612475876001613286565b90506001600160a01b038816915060208301515f835f805160206135278339815191525f80a460025b8181146124c757806020028401515f845f805160206135278339815191525f80a460010161249e565b508660010361254f575f6001600160a01b0316886001600160a01b0316876001600160a01b03167fc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62865f815181106125215761252161302d565b60200260200101516001604051612542929190918252602082015260400190565b60405180910390a46125a7565b5f6001600160a01b0316886001600160a01b0316876001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb868860405161259e929190613299565b60405180910390a45b611d5b86895f86611dad565b6060806001600160a01b0384166125dc57604051622e076360e81b815260040160405180910390fd5b825f036125fc5760405163b562e8dd60e01b815260040160405180910390fd5b33836001600160401b03811115612615576126156129c2565b60405190808252806020026020018201604052801561263e578160200160208202803683370190505b509250836001600160401b03811115612659576126596129c2565b604051908082528060200260200182016040528015612682578160200160208202803683370190505b5091505f61268f60045490565b905080855f190310156126a0575f80fd5b5f5b858110156126f2578082018582815181106126bf576126bf61302d565b60200260200101818152505060018482815181106126df576126df61302d565b60209081029190910101526001016126a2565b506001600160a01b0386165f9081526001602052604090206127159082876128de565b8460045f8282546127269190613286565b909155505f9050806127388784613286565b90506001600160a01b038816915082825f5f805160206135278339815191525f80a4600183015b8181146127825780835f5f805160206135278339815191525f80a460010161275f565b50876001600160a01b03165f6001600160a01b0316856001600160a01b03167f4a39dc06d4c0dbc64b70af90fd698a233a518aa5d07e595d983b8c0526c8f7fb89896040516127d2929190613299565b60405180910390a46127e6845f8a89611dad565b505050509250929050565b600881901c5f818152602084905260409020545f19919060ff84191690811b901c81158117612831575b5081015f8181526040902054811581171561281b575b80156128d6576128c7817f0706060506020504060203020504030106050205030304010505030400000000601f6f8421084210842108cc6318c6db6d54be831560081b6fffffffffffffffffffffffffffffffff851160071b1784811c6001600160401b031060061b1784811c63ffffffff1060051b1784811c61ffff1060041b1784811c60ff1060031b1793841c1c161a1790565b600883901b178481115f031792505b505092915050565b5f1960ff8316846020528360081c5f526101018382011061293a575f805160408220805485851b1790559390910160ff811693600181019160081c015b80821461293657815f528360405f205560018201915061291b565b505f525b60405f208284610100031c821b8154178155505050505050565b80356001600160a01b03811681146110e3575f80fd5b5f806040838503121561297b575f80fd5b61298483612954565b946020939093013593505050565b6001600160e01b031981168114610737575f80fd5b5f602082840312156129b7575f80fd5b8135610dd881612992565b634e487b7160e01b5f52604160045260245ffd5b601f8201601f191681016001600160401b03811182821017156129fb576129fb6129c2565b6040525050565b5f6001600160401b03831115612a1a57612a1a6129c2565b604051612a31601f8501601f1916602001826129d6565b809150838152848484011115612a45575f80fd5b838360208301375f60208583010152509392505050565b5f60208284031215612a6c575f80fd5b81356001600160401b03811115612a81575f80fd5b8201601f81018413612a91575f80fd5b610a4e84823560208401612a02565b5f5b83811015612aba578181015183820152602001612aa2565b50505f910152565b5f8151808452612ad9816020860160208601612aa0565b601f01601f19169290920160200192915050565b602081525f610dd86020830184612ac2565b5f60208284031215612b0f575f80fd5b5035919050565b5f805f60608486031215612b28575f80fd5b612b3184612954565b9250612b3f60208501612954565b9150604084013590509250925092565b5f805f60608486031215612b61575f80fd5b612b6a84612954565b95602085013595506040909401359392505050565b5f6001600160401b03821115612b9757612b976129c2565b5060051b60200190565b5f82601f830112612bb0575f80fd5b81356020612bbd82612b7f565b604051612bca82826129d6565b80915083815260208101915060208460051b870101935086841115612bed575f80fd5b602086015b84811015612c095780358352918301918301612bf2565b509695505050505050565b5f82601f830112612c23575f80fd5b610dd883833560208501612a02565b5f805f805f60a08688031215612c46575f80fd5b612c4f86612954565b9450612c5d60208701612954565b935060408601356001600160401b0380821115612c78575f80fd5b612c8489838a01612ba1565b94506060880135915080821115612c99575f80fd5b612ca589838a01612ba1565b93506080880135915080821115612cba575f80fd5b50612cc788828901612c14565b9150509295509295909350565b5f8060408385031215612ce5575f80fd5b82356001600160401b0380821115612cfb575f80fd5b818501915085601f830112612d0e575f80fd5b81356020612d1b82612b7f565b604051612d2882826129d6565b83815260059390931b8501820192828101915089841115612d47575f80fd5b948201945b83861015612d6c57612d5d86612954565b82529482019490820190612d4c565b96505086013592505080821115612d81575f80fd5b50612d8e85828601612ba1565b9150509250929050565b5f815180845260208085019450602084015f5b83811015612dc757815187529582019590820190600101612dab565b509495945050505050565b602081525f610dd86020830184612d98565b8015158114610737575f80fd5b5f8060408385031215612e02575f80fd5b612e0b83612954565b91506020830135612e1b81612de4565b809150509250929050565b5f60208284031215612e36575f80fd5b610dd882612954565b5f8060408385031215612e50575f80fd5b612e5983612954565b9150612e6760208401612954565b90509250929050565b5f805f805f60a08688031215612e84575f80fd5b612e8d86612954565b9450612e9b60208701612954565b9350604086013592506060860135915060808601356001600160401b03811115612ec3575f80fd5b612cc788828901612c14565b600181811c90821680612ee357607f821691505b602082108103612f0157634e487b7160e01b5f52602260045260245ffd5b50919050565b601f8211156111e357805f5260205f20601f840160051c81016020851015612f2c5750805b601f840160051c820191505b81811015610a9c575f8155600101612f38565b81516001600160401b03811115612f6457612f646129c2565b612f7881612f728454612ecf565b84612f07565b602080601f831160018114612fab575f8415612f945750858301515b5f19600386901b1c1916600185901b178555611d5f565b5f85815260208120601f198616915b82811015612fd957888601518255948401946001909101908401612fba565b5085821015612ff657878501515f19600388901b60f8161c191681555b5050505050600190811b01905550565b634e487b7160e01b5f52601160045260245ffd5b8181038181111561068057610680613006565b634e487b7160e01b5f52603260045260245ffd5b808202811582820484141761068057610680613006565b634e487b7160e01b5f52601260045260245ffd5b5f8261307a5761307a613058565b500490565b5f815461308b81612ecf565b600182811680156130a357600181146130b8576130e4565b60ff19841687528215158302870194506130e4565b855f526020805f205f5b858110156130db5781548a8201529084019082016130c2565b50505082870194505b5050505092915050565b5f6130f9828561307f565b8351613109818360208801612aa0565b01949350505050565b707b226e616d65223a20224d494e4552202360781b815284515f9061313e816011850160208a01612aa0565b701116113232b9b1b934b83a34b7b7111d1160791b601191840191820152855161316f816022840160208a01612aa0565b7f222c2265787465726e616c5f75726c223a2268747470733a2f2f6d696e65722e602292909101918201526f313ab4b63211161134b6b0b3b2911d1160811b60428201526131c0605282018661307f565b905083516131d2818360208801612aa0565b019695505050505050565b7f646174613a6170706c69636174696f6e2f6a736f6e3b757466382c000000000081525f835161321481601b850160208801612aa0565b7f222c2261747472696275746573223a5b7b2274726169745f74797065223a2243601b918401918201526e37b637b91116113b30b63ab2911d1160891b603b820152835161326981604a840160208801612aa0565b63227d5d7d60e01b604a9290910191820152604e01949350505050565b8082018082111561068057610680613006565b604081525f6132ab6040830185612d98565b82810360208401526132bd8185612d98565b95945050505050565b5f600182016132d7576132d7613006565b5060010190565b5f826132ec576132ec613058565b500690565b5f60208284031215613301575f80fd5b8151610dd881612de4565b6001600160a01b03868116825285166020820152604081018490526060810183905260a0608082018190525f9061334590830184612ac2565b979650505050505050565b5f60208284031215613360575f80fd5b8151610dd881612992565b5f60033d11156133815760045f803e505f5160e01c5b90565b5f60443d10156133915790565b6040516003193d81016004833e81513d6001600160401b0381602484011181841117156133c057505050505090565b82850191508151818111156133d85750505050505090565b843d87010160208285010111156133f25750505050505090565b613401602082860101876129d6565b509095945050505050565b6001600160a01b03858116825284166020820152604081018390526080606082018190525f9061343e90830184612ac2565b9695505050505050565b6001600160a01b0386811682528516602082015260a0604082018190525f9061347390830186612d98565b82810360608401526134858186612d98565b905082810360808401526134998185612ac2565b9897505050505050505056fe456e747279206c6576656c204e46547320706f776572656420627920455243313135352e205468652073696c766572204e46547320617265206d696e6564206279206173706972696e6720636f6c6c6563746f727320616e64206d65746963756c6f75736c79206372616674656420666f72206163636573736962696c6974792eddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef526566696e6564204e46547320706f776572656420627920455243313135352e205468652073696c766572204e46547320617265206d696e656420627920736561736f6e656420656e7468757369617374732c20616464696e6720616e206578747261206c61796572206f6620736f706869737469636174696f6e20746f20796f757220706f7274666f6c696f2e4c6567656e64617279204e46547320706f776572656420627920455243313135352e20546865204469616d6f6e64204e46547320617265206d65746963756c6f75736c79206d696e656420627920696e64757374727920656c6974657320616e642063726166746564207769746820756e706172616c6c656c656420707265636973696f6e2c20726570726573656e74696e6720746865207a656e697468206f66206c757875727920616e64206469676974616c2061727469737472792e50726573746967696f7573204e46547320706f776572656420627920455243313135352e2054686520676f6c64204e46547320617265206361726566756c6c79206d696e65642062792065787065727420636f6c6c6563746f727320616e64206d65746963756c6f75736c792063726166746564207769746820676f6c64656e20657863656c6c656e63652c2073796d626f6c697a696e67207468652070696e6e61636c65206f66206469676974616c2072617269747920616e64206578636c757369766974792ea26469706673582212200d9095308341802128db3aff935bdbd095f9b7124e968a65e54b8074087e4a2f64736f6c63430008180033

Deployed Bytecode

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

Deployed Bytecode Sourcemap

78529:4904:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48719:367;;;;;;:::i;:::-;;:::i;:::-;;;597:25:1;;;585:2;570:18;48719:367:0;;;;;;;;46843:577;;;;;;:::i;:::-;;:::i;:::-;;;1184:14:1;;1177:22;1159:41;;1147:2;1132:18;46843:577:0;1019:187:1;80609:91:0;;;;;;:::i;:::-;;:::i;:::-;;44351:18;;;:::i;:::-;;;;;;;:::i;44100:46::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;44100:46:0;;;;;;-1:-1:-1;;;;;3632:32:1;;;3614:51;;3602:2;3587:18;44100:46:0;3468:203:1;71223:514:0;;;;;;:::i;:::-;;:::i;78963:32::-;;;;;;;;;83322:108;;;;;;:::i;:::-;;:::i;44523:36::-;;;;;80389:98;;;;;;:::i;:::-;;:::i;71886:856::-;;;;;;:::i;:::-;;:::i;48364:204::-;;;;;;:::i;:::-;;:::i;50894:419::-;;;;;;:::i;:::-;;:::i;44456:31::-;;;;;;;;6605:4:1;6593:17;;;6575:36;;6563:2;6548:18;44456:31:0;6433:184:1;49252:531:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;80164:91::-;;;:::i;45753:119::-;;;;;;:::i;:::-;;:::i;44636:37::-;;;;;80263:118;;;;;;:::i;:::-;;:::i;44591:38::-;;;;;48022:114;;;;;;:::i;:::-;-1:-1:-1;;;;;48112:16:0;48085:7;48112:16;;;:9;:16;;;;;;;48022:114;2855:103;;;:::i;78230:292::-;;;;;;:::i;:::-;;:::i;2180:87::-;2226:7;2253:6;-1:-1:-1;;;;;2253:6:0;2180:87;;44399:20;;;:::i;76509:1269::-;;;;;;:::i;:::-;;:::i;44719:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;44846:29;;;;;;49856:187;;;;;;:::i;:::-;;:::i;70838:186::-;;;;;;:::i;:::-;;:::i;46580:191::-;;;;;;:::i;:::-;;:::i;80708:2606::-;;;;;;:::i;:::-;;:::i;78622:26::-;;;:::i;71032:183::-;;;;;;:::i;:::-;-1:-1:-1;;;;;71180:18:0;;;71148:7;71180:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;71032:183;80495:106;;;;;;:::i;:::-;;:::i;50115:218::-;;;;;;:::i;:::-;-1:-1:-1;;;;;50288:27:0;;;50259:4;50288:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;50115:218;50405:412;;;;;;:::i;:::-;;:::i;78594:21::-;;;:::i;3113:220::-;;;;;;:::i;:::-;;:::i;78932:24::-;;;;;;48719:367;48850:7;-1:-1:-1;;;;;48879:21:0;;48875:89;;48924:28;;-1:-1:-1;;;48924:28:0;;;;;;;;;;;48875:89;-1:-1:-1;;;;;48978:15:0;;;;;;:6;:15;;;;;;;;35449:1;35440:10;;;35429:22;;;;;;;;;35464:4;35456:12;;35429:40;35428:46;48974:105;;;-1:-1:-1;49025:1:0;49018:8;;48974:105;-1:-1:-1;49066:1:0;48974:105;48719:367;;;;:::o;46843:577::-;46990:4;-1:-1:-1;;;;;;47032:41:0;;-1:-1:-1;;;47032:41:0;;:110;;-1:-1:-1;;;;;;;47090:52:0;;-1:-1:-1;;;47090:52:0;47032:110;:165;;;-1:-1:-1;;;;;;;47159:38:0;;-1:-1:-1;;;47159:38:0;47032:165;:207;;;-1:-1:-1;;;;;;;;;;47214:25:0;;;47032:207;:284;;;-1:-1:-1;;;;;;;;;;47291:25:0;;;47032:284;:380;;;-1:-1:-1;;;;;;;;;;25108:40:0;;;47376:36;24949:207;80609:91;2066:13;:11;:13::i;:::-;80677:15:::1;80685:6;80677:7;:15::i;:::-;80609:91:::0;:::o;44351:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;71223:514::-;71323:4;71361:10;71394:14;46259:13;;;46185:95;71394:14;71386:5;:22;:35;;;;;71420:1;71412:5;:9;71386:35;71382:326;;;71443:23;71453:5;71460;71443:9;:23::i;:::-;71438:97;;71494:25;;-1:-1:-1;;;71494:25:0;;-1:-1:-1;;;;;3632:32:1;;71494:25:0;;;3614:51:1;3587:18;;71494:25:0;;;;;;;;71438:97;71551:18;;;;:11;:18;;;;;;;;;:28;;-1:-1:-1;;;;;;71551:28:0;-1:-1:-1;;;;;71551:28:0;;;;;;;;;71601:31;;597:25:1;;;71601:31:0;;;;;;570:18:1;71601:31:0;;;;;;;71382:326;;;71665:31;71674:5;71681:7;71690:5;71665:8;:31::i;:::-;-1:-1:-1;71725:4:0;;71223:514;-1:-1:-1;;;71223:514:0:o;83322:108::-;83377:13;83410:12;83419:2;83410:8;:12::i;80389:98::-;2066:13;:11;:13::i;:::-;80461:7:::1;:18;80471:8:::0;80461:7;:18:::1;:::i;:::-;;80389:98:::0;:::o;71886:856::-;72007:4;72036:14;46259:13;;;46185:95;72036:14;72028:5;:22;72024:689;;;-1:-1:-1;;;;;72072:12:0;;;;;;:6;:12;;;;;;;;35449:1;35440:10;;;35429:22;;;;;;;;;35464:4;35456:12;;35429:40;35428:46;72067:97;;72123:25;;-1:-1:-1;;;72123:25:0;;-1:-1:-1;;;;;3632:32:1;;72123:25:0;;;3614:51:1;3587:18;;72123:25:0;3468:203:1;72067:97:0;72202:10;-1:-1:-1;;;;;72202:18:0;;;;;;:74;;-1:-1:-1;;;;;;50288:27:0;;50259:4;50288:27;;;:18;:27;;;;;;;;72265:10;50288:37;;;;;;;;;;72241:35;72202:74;:127;;;;-1:-1:-1;72311:18:0;;;;:11;:18;;;;;;-1:-1:-1;;;;;72311:18:0;72297:10;:32;;72202:127;72180:238;;;72371:31;;-1:-1:-1;;;72371:31:0;;72391:10;72371:31;;;3614:51:1;3587:18;;72371:31:0;3468:203:1;72180:238:0;72434:40;72444:4;72450:2;72454:12;72468:5;72434:9;:40::i;:::-;72498:18;;;;:11;:18;;;;;;;;72491:25;;-1:-1:-1;;;;;;72491:25:0;;;72533:48;;;;;;;;;;;;72551:4;;72557:2;;72510:5;;72491:25;;72533:17;:48::i;:::-;72024:689;;;72614:40;72630:4;72636:10;72648:5;72614:15;:40::i;:::-;72669:32;72679:4;72685:2;72689:5;72696:4;72669:9;:32::i;48364:204::-;48490:7;48517:43;48540:5;48547:12;48540:5;48547:4;:12;:::i;:::-;-1:-1:-1;;;;;48517:13:0;;;;;;:6;:13;;;;;;:43;:22;:43::i;:::-;48510:50;48364:204;-1:-1:-1;;;;48364:204:0:o;50894:419::-;-1:-1:-1;;;;;51111:20:0;;376:10;51111:20;;:60;;-1:-1:-1;51135:36:0;51152:4;376:10;50115:218;:::i;51135:36::-;51105:138;;51196:35;;-1:-1:-1;;;51196:35:0;;;;;;;;;;;51105:138;51253:52;51276:4;51282:2;51286:3;51291:7;51300:4;51253:22;:52::i;:::-;50894:419;;;;;:::o;49252:531::-;49408:16;49465:3;:10;49446:8;:15;:29;49442:91;;49499:22;;-1:-1:-1;;;49499:22:0;;;;;;;;;;;49442:91;49545:30;49592:8;:15;-1:-1:-1;;;;;49578:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49578:30:0;;49545:63;;49626:9;49621:122;49645:8;:15;49641:1;:19;49621:122;;;49701:30;49711:8;49720:1;49711:11;;;;;;;;:::i;:::-;;;;;;;49724:3;49728:1;49724:6;;;;;;;;:::i;:::-;;;;;;;49701:9;:30::i;:::-;49682:13;49696:1;49682:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;49662:3;;49621:122;;;-1:-1:-1;49762:13:0;49252:531;-1:-1:-1;;;49252:531:0:o;80164:91::-;2066:13;:11;:13::i;:::-;80234::::1;::::0;;-1:-1:-1;;80217:30:0;::::1;80234:13;::::0;;::::1;80233:14;80217:30;::::0;;80164:91::o;45753:119::-;2066:13;:11;:13::i;:::-;-1:-1:-1;;;;;45839:17:0;;;::::1;;::::0;;;:9:::1;:17;::::0;;;;:25;;-1:-1:-1;;45839:25:0::1;::::0;::::1;;::::0;;;::::1;::::0;;45753:119::o;80263:118::-;2066:13;:11;:13::i;:::-;80370:3:::1;80345:21;80359:7:::0;80345:11:::1;:21;:::i;:::-;80344:29;;;;:::i;:::-;80332:9;:41:::0;-1:-1:-1;80263:118:0:o;2855:103::-;2066:13;:11;:13::i;:::-;2920:30:::1;2947:1;2920:18;:30::i;:::-;2855:103::o:0;78230:292::-;78333:16;78371:14;:12;:14::i;:::-;78389:1;78371:19;78367:75;;-1:-1:-1;;78414:16:0;;;78428:1;78414:16;;;;;;;;;78230:292::o;78367:75::-;78459:55;78475:5;46097:1;46259:13;;76509:1269;:::i;44399:20::-;;;;;;;:::i;76509:1269::-;76641:16;76708:4;76699:5;:13;76695:45;;76721:19;;-1:-1:-1;;;76721:19:0;;;;;;;;;;;76695:45;46097:1;76820:5;:23;76816:87;;;46097:1;76864:23;;76816:87;76970:17;76990:14;46259:13;;;46185:95;76990:14;76970:34;;77030:9;77023:4;:16;77019:73;;;77067:9;77060:16;;77019:73;77108:22;77157:4;77149:5;:12;77145:158;;;77199:29;77209:5;77216;77223:4;77199:9;:29::i;:::-;77182:46;;77145:158;;;-1:-1:-1;77286:1:0;77145:158;77319:25;77361:14;-1:-1:-1;;;;;77347:29:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77347:29:0;-1:-1:-1;;;;;;77425:13:0;;77393:29;77425:13;;;:6;:13;;;;;77319:57;;-1:-1:-1;77514:5:0;;77455:275;77557:14;77542:11;:29;77455:275;;35449:1;35440:10;;;35162;35429:22;;;;;;;;;;;35464:4;35456:12;;35429:40;35473:1;35428:46;77628:87;;;77694:1;77668:8;77677:13;;;;;;77668:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;77628:87;77590:3;;;;;77455:275;;;-1:-1:-1;77751:8:0;;76509:1269;-1:-1:-1;;;;;;;;76509:1269:0:o;49856:187::-;49983:52;376:10;50016:8;50026;49983:18;:52::i;70838:186::-;70907:4;70940:10;70961:33;70940:10;70978:2;70982:5;70989:4;70961:9;:33::i;46580:191::-;-1:-1:-1;;;;;46740:15:0;;46711:4;46740:15;;;:6;:15;;;;;;;;35449:1;35440:10;;;35429:22;;;;;;;;35464:4;35456:12;;35429:40;35428:46;46740:23;46733:30;46580:191;-1:-1:-1;;;46580:191:0:o;80708:2606::-;80759:13;80795:14;46259:13;;;46185:95;80795:14;80789:2;:20;80785:55;;80818:22;;-1:-1:-1;;;80818:22:0;;;;;;;;;;;80785:55;80887:1;80863:13;80873:2;80863:9;:13::i;:::-;80857:27;:31;80853:57;;;80897:13;80907:2;80897:9;:13::i;80853:57::-;80954:1;80931:12;80925:26;;;;;:::i;:::-;;;:30;80921:2386;;;81001:12;81015:13;:2;:11;:13::i;:::-;80984:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;80970:60;;80708:2606;;;:::o;80921:2386::-;81061:10;81114:2;81097:20;;;;;;14688:19:1;;14732:2;14723:12;;14559:182;81097:20:0;;;;;;;;;;;;;81087:31;;;;;;81074:46;;81061:59;;81137:19;81171;81205:25;81259:2;81251:4;:10;;;81247:1281;;81282:29;;;;;;;;;;;;;-1:-1:-1;;;81282:29:0;;;;;81330:17;;;;;;;;;;;;;-1:-1:-1;;;81330:17:0;;;;;81366:206;;;;;;;;;;;;;;;;;;;81247:1281;;;81606:3;81598:4;:11;;;81594:934;;81630:29;;;;;;;;;;;;;-1:-1:-1;;;81630:29:0;;;;;81678:14;;;;;;;;;;;;;-1:-1:-1;;;81678:14:0;;;;;81711:216;;;;;;;;;;;;;;;;;;;81594:934;;;81961:3;81953:4;:11;;;81949:579;;81985:29;;;;;;;;;;;;;-1:-1:-1;;;81985:29:0;;;;;82033:16;;;;;;;;;;;;;-1:-1:-1;;;82033:16:0;;;;;82068:158;;;;;;;;;;;;;;;;;;;81949:579;;;82260:3;82252:4;:11;;;82248:280;;82284:29;;;;;;;;;;;;;-1:-1:-1;;;82284:29:0;;;;;82332:16;;;;;;;;;;;;;-1:-1:-1;;;82332:16:0;;;;;82367:145;;;;;;;;;;;;;;;;;;;82248:280;82544:26;82679:13;:2;:11;:13::i;:::-;82757:11;82864:7;82894:5;82598:320;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;82544:389;;83100:12;83215:5;83001:275;;;;;;;;;:::i;:::-;;;;;;;;;;;;;82948:347;;;;;;;80708:2606;;;:::o;80921:2386::-;80708:2606;;;:::o;78622:26::-;;;;;;;:::i;80495:106::-;2066:13;:11;:13::i;:::-;80569:12:::1;:24;80584:9:::0;80569:12;:24:::1;:::i;50405:412::-:0;-1:-1:-1;;;;;50595:20:0;;376:10;50595:20;;:60;;-1:-1:-1;50619:36:0;50636:4;376:10;50115:218;:::i;50619:36::-;50591:219;;;50672:51;50690:4;50696:2;50700;50704:6;50712:4;50718;50672:17;:51::i;:::-;50591:219;;;50763:35;;-1:-1:-1;;;50763:35:0;;;;;;;;;;;78594:21;;;;;;;:::i;3113:220::-;2066:13;:11;:13::i;:::-;-1:-1:-1;;;;;3198:22:0;::::1;3194:93;;3244:31;::::0;-1:-1:-1;;;3244:31:0;;3272:1:::1;3244:31;::::0;::::1;3614:51:1::0;3587:18;;3244:31:0::1;3468:203:1::0;3194:93:0::1;3297:28;3316:8;3297:18;:28::i;2345:166::-:0;2226:7;2253:6;-1:-1:-1;;;;;2253:6:0;376:10;2405:23;2401:103;;2452:40;;-1:-1:-1;;;2452:40:0;;376:10;2452:40;;;3614:51:1;3587:18;;2452:40:0;3468:203:1;57734:88:0;57801:4;:13;57808:6;57801:4;:13;:::i;74846:164::-;74965:37;74974:5;74981:7;74990:5;74997:4;74965:8;:37::i;:::-;74846:164;;;:::o;72750:368::-;-1:-1:-1;;;;;72888:18:0;;72884:88;;72930:30;;-1:-1:-1;;;72930:30:0;;72957:1;72930:30;;;3614:51:1;3587:18;;72930:30:0;3468:203:1;72884:88:0;-1:-1:-1;;;;;72986:16:0;;72982:88;;73026:32;;-1:-1:-1;;;73026:32:0;;73055:1;73026:32;;;3614:51:1;3587:18;;73026:32:0;3468:203:1;72982:88:0;73080:30;73088:4;73094:2;73098:5;73105:4;73080:7;:30::i;:::-;72750:368;;;;:::o;51812:1710::-;-1:-1:-1;;;;;52017:16:0;;52013:79;;52057:23;;-1:-1:-1;;;52057:23:0;;;;;;;;;;;52013:79;376:10;52104:16;52169:21;52187:2;52169:17;:21::i;:::-;52146:44;;52265:6;52275:1;52265:11;:35;;;;-1:-1:-1;;;;;;52280:12:0;;;;;;:6;:12;;;;;;;;35449:1;35440:10;;;35429:22;;;;;;;;;35464:4;35456:12;;35429:40;35428:46;52280:20;52261:261;;;-1:-1:-1;;;;;52317:12:0;;;;;;;:6;:12;;;;;;;;35941:1;35932:10;;;35921:22;;;;;;;;;:48;;35963:4;35955:12;;35949:19;;;35947:22;;35921:48;;;;;;52354:10;;;;;;;;;;;35722:22;;;;;;;;:47;;;;;;;;52387:40;;52317:12;;52354:10;;52407:12;;52387:9;:40::i;:::-;52261:261;;;52467:43;;-1:-1:-1;;;52467:43:0;;;;;;;;;;;52261:261;-1:-1:-1;;;;;52720:25:0;;;;52773:27;;53126:6;52720:25;52773:27;-1:-1:-1;;;;;;;;;;;52534:16:0;;52857:304;53220:2;-1:-1:-1;;;;;53189:46:0;53214:4;-1:-1:-1;;;;;53189:46:0;53204:8;-1:-1:-1;;;;;53189:46:0;;53224:2;53228:6;53189:46;;;;;;17467:25:1;;;17523:2;17508:18;;17501:34;17455:2;17440:18;;17293:248;53189:46:0;;;;;;;;53248:44;53268:8;53278:4;53284:2;53288:3;53248:19;:44::i;:::-;53309:5;53305:209;;;53329:185;53378:8;53405:4;53428:2;53449;53470:6;53495:4;53329:30;:185::i;:::-;52002:1520;;;;51812:1710;;;;;;:::o;75512:603::-;-1:-1:-1;;;;;71180:18:0;;;75646:24;71180:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;75713:37:0;;75709:399;;75790:5;75771:16;:24;75767:214;;;75823:142;;-1:-1:-1;;;75823:142:0;;-1:-1:-1;;;;;17766:32:1;;75823:142:0;;;17748:51:1;17815:18;;;17808:34;;;17858:18;;;17851:34;;;17721:18;;75823:142:0;17546:345:1;75767:214:0;76024:57;76033:5;76040:7;76068:5;76049:16;:24;76075:5;76024:8;:57::i;40682:820::-;40811:13;40888:1;40879:10;;;40928:4;40920:12;;40970:3;40953:14;;;:20;40947:417;;41019:10;:18;;;;;;;;;;;41003:44;;41019:27;;41003:15;:44::i;:::-;41097:14;;41165:4;41146:23;;;41097:14;-1:-1:-1;41221:8:0;;;;41066:17;;41116:1;41096:21;41086:32;41216:133;41241:9;41231:6;:19;41216:133;;41310:10;:18;;;;;;;;;;;41294:35;;:15;:35::i;:::-;41285:44;;;;41252:8;;;;;41216:133;;;40976:388;40947:417;41422:10;:18;;;;;;;;;;;41387:96;;41422:27;;41455:3;:12;;;41421:47;41387:15;:96::i;:::-;41378:105;;;;40682:820;-1:-1:-1;;;;;40682:820:0:o;53880:3010::-;54103:7;:14;54089:3;:10;:28;54085:90;;54141:22;;-1:-1:-1;;;54141:22:0;;;;;;;;;;;54085:90;-1:-1:-1;;;;;54191:16:0;;54187:79;;54231:23;;-1:-1:-1;;;54231:23:0;;;;;;;;;;;54187:79;376:10;54276:16;54378:371;54402:3;:10;54398:1;:14;54378:371;;;54434:10;54447:3;54451:1;54447:6;;;;;;;;:::i;:::-;;;;;;;54434:19;;54468:14;54485:7;54493:1;54485:10;;;;;;;;:::i;:::-;;;;;;;54468:27;;54516:6;54526:1;54516:11;:35;;;;-1:-1:-1;;;;;;54531:12:0;;;;;;:6;:12;;;;;;;;35449:1;35440:10;;;35429:22;;;;;;;;;35464:4;35456:12;;35429:40;35428:46;54531:20;54512:226;;;-1:-1:-1;;;;;;54572:12:0;;;;;;;:6;:12;;;;;;;;35941:1;35932:10;;;35921:22;;;;;;;;;:48;;35963:4;35955:12;;;35949:19;;;35947:22;;35921:48;;;;;54613:10;;;;;;;;;;;35722:22;;;;;;;;;:47;;;;;;;;54414:3;54378:371;;;;54759:53;54769:4;54775:2;54794:3;:10;54779:12;:25;;;;:::i;:::-;54806:5;54759:9;:53::i;:::-;54825:16;54852:18;54881:11;54895:3;:10;54908:1;54895:14;;;;:::i;:::-;54881:28;;-1:-1:-1;;;;;55392:4:0;55388:27;55374:41;;-1:-1:-1;;;;;55445:2:0;55441:25;55429:37;;55807:4;55802:3;55798:14;55792:21;55756:8;55716:10;-1:-1:-1;;;;;;;;;;;55603:1:0;55546;55523:319;56130:1;56092:481;56166:3;56157:7;56154:16;56092:481;;56529:7;56523:4;56519:18;56514:3;56510:28;56504:35;56473:8;56440:10;-1:-1:-1;;;;;;;;;;;56368:1:0;56344;56317:241;56215:1;56202:15;56092:481;;;56096:50;56631:2;-1:-1:-1;;;;;56601:47:0;56625:4;-1:-1:-1;;;;;56601:47:0;56615:8;-1:-1:-1;;;;;56601:47:0;;56635:3;56640:7;56601:47;;;;;;;:::i;:::-;;;;;;;;56661:44;56681:8;56691:4;56697:2;56701:3;56661:19;:44::i;:::-;56718:164;56768:8;56791:4;56810:2;56827:3;56845:7;56867:4;56718:35;:164::i;:::-;54074:2816;;;;53880:3010;;;;;:::o;3493:191::-;3567:16;3586:6;;-1:-1:-1;;;;;3603:17:0;;;-1:-1:-1;;;;;;3603:17:0;;;;;;3636:40;;3586:6;;;;;;;3636:40;;3567:16;3636:40;3556:128;3493:191;:::o;46378:114::-;46425:7;46097:1;46259:13;;46452:32;;;;:::i;:::-;46445:39;;46378:114;:::o;65323:331::-;65478:8;-1:-1:-1;;;;;65469:17:0;:5;-1:-1:-1;;;;;65469:17:0;;65461:71;;;;-1:-1:-1;;;65461:71:0;;18698:2:1;65461:71:0;;;18680:21:1;18737:2;18717:18;;;18710:30;18776:34;18756:18;;;18749:62;-1:-1:-1;;;18827:18:1;;;18820:39;18876:19;;65461:71:0;18496:405:1;65461:71:0;-1:-1:-1;;;;;65543:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;65543:46:0;;;;;;;;;;65605:41;;1159::1;;;65605::0;;1132:18:1;65605:41:0;;;;;;;65323:331;;;:::o;47831:105::-;47891:13;47924:4;47917:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47831:105;;;:::o;13860:723::-;13916:13;14137:5;14146:1;14137:10;14133:53;;-1:-1:-1;;14164:10:0;;;;;;;;;;;;-1:-1:-1;;;14164:10:0;;;;;13860:723::o;14133:53::-;14211:5;14196:12;14252:78;14259:9;;14252:78;;14285:8;;;;:::i;:::-;;-1:-1:-1;14308:10:0;;-1:-1:-1;14316:2:0;14308:10;;:::i;:::-;;;14252:78;;;14340:19;14372:6;-1:-1:-1;;;;;14362:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14362:17:0;;14340:39;;14390:154;14397:10;;14390:154;;14424:11;14434:1;14424:11;;:::i;:::-;;-1:-1:-1;14493:10:0;14501:2;14493:5;:10;:::i;:::-;14480:24;;:2;:24;:::i;:::-;14467:39;;14450:6;14457;14450:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;14450:56:0;;;;;;;;-1:-1:-1;14521:11:0;14530:2;14521:11;;:::i;:::-;;;14390:154;;75018:486;-1:-1:-1;;;;;75174:19:0;;75170:91;;75217:32;;-1:-1:-1;;;75217:32:0;;75246:1;75217:32;;;3614:51:1;3587:18;;75217:32:0;3468:203:1;75170:91:0;-1:-1:-1;;;;;75275:21:0;;75271:92;;75320:31;;-1:-1:-1;;;75320:31:0;;75348:1;75320:31;;;3614:51:1;3587:18;;75320:31:0;3468:203:1;75271:92:0;-1:-1:-1;;;;;75373:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;75419:78;;;;75470:7;-1:-1:-1;;;;;75454:31:0;75463:5;-1:-1:-1;;;;;75454:31:0;;75479:5;75454:31;;;;597:25:1;;585:2;570:18;;451:177;75454:31:0;;;;;;;;75018:486;;;;:::o;73126:1712::-;-1:-1:-1;;;;;73288:15:0;;;73266:19;73288:15;;;:9;:15;;;;;;;73334:13;;;;;;;;73362:19;;;73358:109;;;73405:50;;-1:-1:-1;;;73405:50:0;;-1:-1:-1;;;;;17766:32:1;;73405:50:0;;;17748:51:1;17815:18;;;17808:34;;;17858:18;;;17851:34;;;17721:18;;73405:50:0;17546:345:1;73358:109:0;-1:-1:-1;;;;;73580:15:0;;;;;;;:9;:15;;;;;;73598:19;;;73580:37;;73748:13;;;;;;;;;;73764:17;;;73748:33;;73810:25;;-1:-1:-1;;;;;;;;;;;73810:25:0;;;73612:5;597:25:1;;585:2;570:18;;451:177;73810:25:0;;;;;;;;73852:4;73848:983;;;-1:-1:-1;;;;;73944:15:0;;73933:8;73944:15;;;:9;:15;;;;;;;;;73974:235;;74003:22;74105:12;74082:19;74096:5;74082:11;:19;:::i;:::-;74081:36;;;;:::i;:::-;74029:26;74043:12;74029:11;:26;:::i;:::-;74028:90;;;;:::i;:::-;74003:115;-1:-1:-1;74141:18:0;;74137:56;;74161:32;74172:4;74178:14;74161:10;:32::i;:::-;73984:225;73974:235;-1:-1:-1;;;;;74293:13:0;;;;;;:9;:13;;;;;;;;74288:532;;74331:10;;74345:1;74331:15;:22;;;;;74350:3;74331:22;:41;;;;-1:-1:-1;2226:7:0;2253:6;-1:-1:-1;;;;;74357:15:0;;;2253:6;;74357:15;74331:41;74327:478;;;-1:-1:-1;;;;;74455:13:0;;;;;;:9;:13;;;;;:20;;-1:-1:-1;;74455:20:0;74471:4;74455:20;;;74511:1;74498:10;:14;74327:478;;;74561:22;74651:24;74663:12;74651:9;:24;:::i;:::-;74634:12;74588:17;74600:5;74588:9;:17;:::i;:::-;74587:59;;;;:::i;:::-;74586:90;;;;:::i;:::-;74561:115;-1:-1:-1;74703:18:0;;74699:86;;74748:37;74766:2;74770:14;74748:17;:37::i;74699:86::-;74538:267;74327:478;73858:973;73848:983;73255:1583;;73126:1712;;;;:::o;70636:194::-;70777:16;;;70791:1;70777:16;;;;;;;;;70729:22;;70777:16;;;;;;;;;;;-1:-1:-1;70777:16:0;70769:24;;70815:7;70804:5;70810:1;70804:8;;;;;;;;:::i;:::-;;;;;;:18;;;;;70636:194;;;:::o;79260:896::-;-1:-1:-1;;;;;79432:13:0;;;;;;:9;:13;;;;;;;;79427:659;;79505:9;;-1:-1:-1;;;;;79488:13:0;;;;;;:9;:13;;;;;;:26;;79462:119;;;;-1:-1:-1;;;79462:119:0;;19365:2:1;79462:119:0;;;19347:21:1;19404:2;19384:18;;;19377:30;19443:33;19423:18;;;19416:61;19494:18;;79462:119:0;19163:355:1;79462:119:0;79600:13;;;;79596:479;;;79675:9;79664:21;;;;:10;:21;;;;;;79688:12;-1:-1:-1;79634:146:0;;;;-1:-1:-1;;;79634:146:0;;19725:2:1;79634:146:0;;;19707:21:1;19764:2;19744:18;;;19737:30;19803:34;19783:18;;;19776:62;-1:-1:-1;;;19854:18:1;;;19847:34;19898:19;;79634:146:0;19523:400:1;79634:146:0;79810:9;79799:21;;;;:10;:21;;;;;79823:12;79799:36;;-1:-1:-1;;;;;79886:23:0;;;:28;:92;;;;-1:-1:-1;79951:9:0;79943:30;:35;79886:92;79856:203;;;;-1:-1:-1;;;79856:203:0;;20130:2:1;79856:203:0;;;20112:21:1;20169:2;20149:18;;;20142:30;20208:34;20188:18;;;20181:62;-1:-1:-1;;;20259:18:1;;;20252:35;20304:19;;79856:203:0;19928:401:1;79856:203:0;80098:50;72750:368;67890:1771;-1:-1:-1;;;;;68105:13:0;;6159:20;6207:8;68101:1553;;68141:57;;-1:-1:-1;;;68141:57:0;;-1:-1:-1;;;68141:57:0;;;20478:52:1;-1:-1:-1;;;;;68141:29:0;;;;;20451:18:1;;68141:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68137:1506;;;68244:220;;-1:-1:-1;;;68244:220:0;;-1:-1:-1;;;;;68244:38:0;;;;;:220;;68309:8;;68344:4;;68375:2;;68404:6;;68437:4;;68244:220;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;68244:220:0;;;;;;;;-1:-1:-1;;68244:220:0;;;;;;;;;;;;:::i;:::-;;;68219:729;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;68823:6;68816:14;;-1:-1:-1;;;68816:14:0;;;;;;;;:::i;68219:729::-;;;68887:41;;-1:-1:-1;;;68887:41:0;;;;;;;;;;;68219:729;-1:-1:-1;;;;;;68561:55:0;;-1:-1:-1;;;68561:55:0;68531:208;;68674:41;;-1:-1:-1;;;68674:41:0;;;;;;;;;;;68531:208;68482:276;68137:1506;;;69013:184;;-1:-1:-1;;;69013:184:0;;-1:-1:-1;;;;;69013:35:0;;;;;:184;;69075:8;;69110:4;;69141:2;;69170:4;;69013:184;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69013:184:0;;;;;;;;-1:-1:-1;;69013:184:0;;;;;;;;;;;;:::i;:::-;;;68988:640;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;69568:40;;-1:-1:-1;;;69568:40:0;;;;;;;;;;;68988:640;-1:-1:-1;;;;;;69268:52:0;;-1:-1:-1;;;69268:52:0;69264:156;;69356:40;;-1:-1:-1;;;69356:40:0;;;;;;;;;;;29148:464;29512:12;29385:11;29378:1;29374:9;;;29370:27;29363:35;;29450:1;29446:9;;;29457:11;29442:27;;;29421:19;;29417:53;29504:1;29500:9;;;29493:17;29489:36;29578:13;29571:21;29566:3;29562:31;-1:-1:-1;;29334:10:0;;;;29551:1;29547:13;29544:50;;29148:464::o;69669:959::-;-1:-1:-1;;;;;69909:13:0;;6159:20;6207:8;69905:716;;69962:203;;-1:-1:-1;;;69962:203:0;;-1:-1:-1;;;;;69962:43:0;;;;;:203;;70028:8;;70059:4;;70086:3;;70112:7;;70142:4;;69962:203;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69962:203:0;;;;;;;;-1:-1:-1;;69962:203:0;;;;;;;;;;;;:::i;:::-;;;69941:669;;;;:::i;:::-;-1:-1:-1;;;;;;70250:60:0;;-1:-1:-1;;;70250:60:0;70224:197;;70360:41;;-1:-1:-1;;;70360:41:0;;;;;;;;;;;63346:1834;-1:-1:-1;;;;;63428:18:0;;63424:79;;63470:21;;-1:-1:-1;;;63470:21:0;;;;;;;;;;;63424:79;46259:13;;376:10;;63607:24;63648:6;-1:-1:-1;;;;;63634:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;63634:21:0;;63607:48;;63666:20;63703:6;-1:-1:-1;;;;;63689:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;63689:21:0;;63666:44;;63753:9;63748:259;63772:6;63768:1;:10;63748:259;;;63817:1;63804:7;63812:1;63804:10;;;;;;;;:::i;:::-;;;;;;;;;;;:14;;;;-1:-1:-1;;;;;63850:12:0;;63837:10;63850:12;;;:6;:12;;;;;;:36;;63875:10;63850:24;:36::i;:::-;63837:49;;63914:2;63905:3;63909:1;63905:6;;;;;;;;:::i;:::-;;;;;;;;;;;:11;;;;-1:-1:-1;;;;;63935:12:0;;;;;;:6;:12;;;;;;;35941:1;35932:10;;;35921:22;;;;;;;;:48;;35963:4;35955:12;;35949:19;;;35947:22;35921:48;;;35932:10;;-1:-1:-1;63780:3:0;63748:259;;;;64158:18;;64201:10;:6;64210:1;64201:10;:::i;:::-;64187:24;;-1:-1:-1;;;;;64266:4:0;64262:27;64248:41;;64474:4;64469:3;64465:14;64459:21;64439:1;64410:10;-1:-1:-1;;;;;;;;;;;64346:1:0;64326;64303:192;64549:1;64511:409;64585:3;64576:7;64573:16;64511:409;;64876:7;64870:4;64866:18;64861:3;64857:28;64851:35;64827:1;64794:10;-1:-1:-1;;;;;;;;;;;64722:1:0;64698;64671:234;64634:1;64621:15;64511:409;;;64515:50;64947:6;64957:1;64947:11;64943:164;;65017:1;-1:-1:-1;;;;;64978:53:0;65003:4;-1:-1:-1;;;;;64978:53:0;64993:8;-1:-1:-1;;;;;64978:53:0;;65021:3;65025:1;65021:6;;;;;;;;:::i;:::-;;;;;;;65029:1;64978:53;;;;;;17467:25:1;;;17523:2;17508:18;;17501:34;17455:2;17440:18;;17293:248;64978:53:0;;;;;;;;64943:164;;;65090:1;-1:-1:-1;;;;;65052:55:0;65076:4;-1:-1:-1;;;;;65052:55:0;65066:8;-1:-1:-1;;;;;65052:55:0;;65094:3;65099:7;65052:55;;;;;;;:::i;:::-;;;;;;;;64943:164;65120:52;65140:8;65150:4;65164:1;65168:3;65120:19;:52::i;58858:1543::-;58966:20;;-1:-1:-1;;;;;59034:16:0;;59030:75;;59074:19;;-1:-1:-1;;;59074:19:0;;;;;;;;;;;59030:75;59119:6;59129:1;59119:11;59115:69;;59154:18;;-1:-1:-1;;;59154:18:0;;;;;;;;;;;59115:69;376:10;59260:6;-1:-1:-1;;;;;59246:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59246:21:0;;59240:27;;59302:6;-1:-1:-1;;;;;59288:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59288:21:0;;59278:31;;59320:20;59343:14;46259:13;;;46185:95;59343:14;59320:37;;59433:12;59423:6;-1:-1:-1;;59403:26:0;:42;;59395:51;;;;;;59466:9;59461:130;59485:6;59481:1;:10;59461:130;;;59541:1;59526:12;:16;59517:3;59521:1;59517:6;;;;;;;;:::i;:::-;;;;;;:25;;;;;59574:1;59561:7;59569:1;59561:10;;;;;;;;:::i;:::-;;;;;;;;;;:14;59493:3;;59461:130;;;;-1:-1:-1;;;;;59678:10:0;;;;;;:6;:10;;;;;:41;;59698:12;59712:6;59678:19;:41::i;:::-;59747:6;59730:13;;:23;;;;;;;:::i;:::-;;;;-1:-1:-1;59766:16:0;;-1:-1:-1;59766:16:0;59807:21;59822:6;59807:12;:21;:::i;:::-;59793:35;;-1:-1:-1;;;;;59881:2:0;59877:25;59865:37;;59967:12;59957:8;59954:1;-1:-1:-1;;;;;;;;;;;59924:1:0;59921;59916:64;60052:1;60038:12;60034:20;59996:253;60089:3;60080:7;60077:16;59996:253;;60226:7;60216:8;60213:1;-1:-1:-1;;;;;;;;;;;60183:1:0;60180;60175:59;60138:1;60125:15;59996:253;;;60000:69;60313:2;-1:-1:-1;;;;;60277:53:0;60309:1;-1:-1:-1;;;;;60277:53:0;60291:8;-1:-1:-1;;;;;60277:53:0;;60317:3;60322:7;60277:53;;;;;;;:::i;:::-;;;;;;;;60343:50;60363:8;60381:1;60385:2;60389:3;60343:19;:50::i;:::-;59019:1382;;;;58858:1543;;;;;:::o;41656:1316::-;41974:1;41970:14;;;41766:19;41998:20;;;42039:4;42032:25;;;42212:4;42196:21;;42190:28;-1:-1:-1;;41940:6:0;41970:14;42089:4;42095:11;;42085:22;42178:41;;;42166:54;;42259:14;;42244:30;;42234:442;;42295:366;-1:-1:-1;42380:24:0;;42454:4;42447:20;;;42525:4;42509:21;;42503:28;42571:14;;42556:30;;42553:89;42295:366;42553:89;42295:366;42701:15;;42697:268;;42763:22;42774:10;26679:66;26552:4;26598:34;26064:9;;26061:1;26057:17;26103:34;26100:41;-1:-1:-1;26097:1:0;26093:49;26036:121;26212:9;;;-1:-1:-1;;;;;26189:33:0;26186:1;26182:41;26176:48;26271:9;;;26259:10;26256:25;26253:1;26249:33;26243:40;26326:9;;;26318:6;26315:21;26312:1;26308:29;26302:36;26379:9;;;26373:4;26370:19;26367:1;26363:27;26357:34;26587:9;;;26583:50;26522:134;26495:269;26454:325;;25894:903;42763:22;42758:1;42748:11;;;42747:38;42914:23;;;42911:1;42907:31;42891:48;;-1:-1:-1;42697:268:0;41792:1180;;41656:1316;;;;:::o;37803:1270::-;38012:1;38008:6;38052:4;38045:5;38041:16;38084:11;38078:4;38071:25;38130:5;38127:1;38123:13;38117:4;38110:27;38184:3;38175:6;38168:5;38164:18;38161:27;38151:704;;38238:4;38228:21;;38244:4;38228:21;;38290:18;;38310:15;;;38287:39;38267:60;;38437:18;;;;38509:4;38485:29;;;-1:-1:-1;38359:19:0;;;38434:1;38430:26;38413:44;38560:242;38605:9;38597:6;38594:21;38560:242;;38720:6;38714:4;38707:20;38779:3;38772:4;38766;38756:21;38749:34;38662:1;38654:6;38650:14;38640:24;;38560:242;;;-1:-1:-1;38827:4:0;38820:20;38151:704;38904:4;38898;38888:21;39034:3;39025:6;39020:3;39016:16;39012:26;39005:5;39001:38;38987:11;38981:18;38978:62;38948:11;38923:132;;;;37803:1270;;;:::o;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;192:254;260:6;268;321:2;309:9;300:7;296:23;292:32;289:52;;;337:1;334;327:12;289:52;360:29;379:9;360:29;:::i;:::-;350:39;436:2;421:18;;;;408:32;;-1:-1:-1;;;192:254:1:o;633:131::-;-1:-1:-1;;;;;;707:32:1;;697:43;;687:71;;754:1;751;744:12;769:245;827:6;880:2;868:9;859:7;855:23;851:32;848:52;;;896:1;893;886:12;848:52;935:9;922:23;954:30;978:5;954:30;:::i;1211:127::-;1272:10;1267:3;1263:20;1260:1;1253:31;1303:4;1300:1;1293:15;1327:4;1324:1;1317:15;1343:249;1453:2;1434:13;;-1:-1:-1;;1430:27:1;1418:40;;-1:-1:-1;;;;;1473:34:1;;1509:22;;;1470:62;1467:88;;;1535:18;;:::i;:::-;1571:2;1564:22;-1:-1:-1;;1343:249:1:o;1597:469::-;1662:5;-1:-1:-1;;;;;1688:6:1;1685:30;1682:56;;;1718:18;;:::i;:::-;1767:2;1761:9;1779:69;1836:2;1815:15;;-1:-1:-1;;1811:29:1;1842:4;1807:40;1761:9;1779:69;:::i;:::-;1866:6;1857:15;;1896:6;1888;1881:22;1936:3;1927:6;1922:3;1918:16;1915:25;1912:45;;;1953:1;1950;1943:12;1912:45;2003:6;1998:3;1991:4;1983:6;1979:17;1966:44;2058:1;2051:4;2042:6;2034;2030:19;2026:30;2019:41;;1597:469;;;;;:::o;2071:451::-;2140:6;2193:2;2181:9;2172:7;2168:23;2164:32;2161:52;;;2209:1;2206;2199:12;2161:52;2249:9;2236:23;-1:-1:-1;;;;;2274:6:1;2271:30;2268:50;;;2314:1;2311;2304:12;2268:50;2337:22;;2390:4;2382:13;;2378:27;-1:-1:-1;2368:55:1;;2419:1;2416;2409:12;2368:55;2442:74;2508:7;2503:2;2490:16;2485:2;2481;2477:11;2442:74;:::i;2527:250::-;2612:1;2622:113;2636:6;2633:1;2630:13;2622:113;;;2712:11;;;2706:18;2693:11;;;2686:39;2658:2;2651:10;2622:113;;;-1:-1:-1;;2769:1:1;2751:16;;2744:27;2527:250::o;2782:271::-;2824:3;2862:5;2856:12;2889:6;2884:3;2877:19;2905:76;2974:6;2967:4;2962:3;2958:14;2951:4;2944:5;2940:16;2905:76;:::i;:::-;3035:2;3014:15;-1:-1:-1;;3010:29:1;3001:39;;;;3042:4;2997:50;;2782:271;-1:-1:-1;;2782:271:1:o;3058:220::-;3207:2;3196:9;3189:21;3170:4;3227:45;3268:2;3257:9;3253:18;3245:6;3227:45;:::i;3283:180::-;3342:6;3395:2;3383:9;3374:7;3370:23;3366:32;3363:52;;;3411:1;3408;3401:12;3363:52;-1:-1:-1;3434:23:1;;3283:180;-1:-1:-1;3283:180:1:o;3676:328::-;3753:6;3761;3769;3822:2;3810:9;3801:7;3797:23;3793:32;3790:52;;;3838:1;3835;3828:12;3790:52;3861:29;3880:9;3861:29;:::i;:::-;3851:39;;3909:38;3943:2;3932:9;3928:18;3909:38;:::i;:::-;3899:48;;3994:2;3983:9;3979:18;3966:32;3956:42;;3676:328;;;;;:::o;4009:322::-;4086:6;4094;4102;4155:2;4143:9;4134:7;4130:23;4126:32;4123:52;;;4171:1;4168;4161:12;4123:52;4194:29;4213:9;4194:29;:::i;:::-;4184:39;4270:2;4255:18;;4242:32;;-1:-1:-1;4321:2:1;4306:18;;;4293:32;;4009:322;-1:-1:-1;;;4009:322:1:o;4336:183::-;4396:4;-1:-1:-1;;;;;4421:6:1;4418:30;4415:56;;;4451:18;;:::i;:::-;-1:-1:-1;4496:1:1;4492:14;4508:4;4488:25;;4336:183::o;4524:730::-;4578:5;4631:3;4624:4;4616:6;4612:17;4608:27;4598:55;;4649:1;4646;4639:12;4598:55;4685:6;4672:20;4711:4;4734:43;4774:2;4734:43;:::i;:::-;4806:2;4800:9;4818:31;4846:2;4838:6;4818:31;:::i;:::-;4869:6;4858:17;;4899:2;4891:6;4884:18;4930:4;4922:6;4918:17;4911:24;;4987:4;4981:2;4978:1;4974:10;4966:6;4962:23;4958:34;4944:48;;5015:3;5007:6;5004:15;5001:35;;;5032:1;5029;5022:12;5001:35;5068:4;5060:6;5056:17;5082:142;5098:6;5093:3;5090:15;5082:142;;;5164:17;;5152:30;;5202:12;;;;5115;;5082:142;;;-1:-1:-1;5242:6:1;4524:730;-1:-1:-1;;;;;;4524:730:1:o;5259:221::-;5301:5;5354:3;5347:4;5339:6;5335:17;5331:27;5321:55;;5372:1;5369;5362:12;5321:55;5394:80;5470:3;5461:6;5448:20;5441:4;5433:6;5429:17;5394:80;:::i;5485:943::-;5639:6;5647;5655;5663;5671;5724:3;5712:9;5703:7;5699:23;5695:33;5692:53;;;5741:1;5738;5731:12;5692:53;5764:29;5783:9;5764:29;:::i;:::-;5754:39;;5812:38;5846:2;5835:9;5831:18;5812:38;:::i;:::-;5802:48;;5901:2;5890:9;5886:18;5873:32;-1:-1:-1;;;;;5965:2:1;5957:6;5954:14;5951:34;;;5981:1;5978;5971:12;5951:34;6004:61;6057:7;6048:6;6037:9;6033:22;6004:61;:::i;:::-;5994:71;;6118:2;6107:9;6103:18;6090:32;6074:48;;6147:2;6137:8;6134:16;6131:36;;;6163:1;6160;6153:12;6131:36;6186:63;6241:7;6230:8;6219:9;6215:24;6186:63;:::i;:::-;6176:73;;6302:3;6291:9;6287:19;6274:33;6258:49;;6332:2;6322:8;6319:16;6316:36;;;6348:1;6345;6338:12;6316:36;;6371:51;6414:7;6403:8;6392:9;6388:24;6371:51;:::i;:::-;6361:61;;;5485:943;;;;;;;;:::o;6622:1208::-;6740:6;6748;6801:2;6789:9;6780:7;6776:23;6772:32;6769:52;;;6817:1;6814;6807:12;6769:52;6857:9;6844:23;-1:-1:-1;;;;;6927:2:1;6919:6;6916:14;6913:34;;;6943:1;6940;6933:12;6913:34;6981:6;6970:9;6966:22;6956:32;;7026:7;7019:4;7015:2;7011:13;7007:27;6997:55;;7048:1;7045;7038:12;6997:55;7084:2;7071:16;7106:4;7129:43;7169:2;7129:43;:::i;:::-;7201:2;7195:9;7213:31;7241:2;7233:6;7213:31;:::i;:::-;7279:18;;;7367:1;7363:10;;;;7355:19;;7351:28;;;7313:15;;;;-1:-1:-1;7391:19:1;;;7388:39;;;7423:1;7420;7413:12;7388:39;7447:11;;;;7467:148;7483:6;7478:3;7475:15;7467:148;;;7549:23;7568:3;7549:23;:::i;:::-;7537:36;;7500:12;;;;7593;;;;7467:148;;;7634:6;-1:-1:-1;;7678:18:1;;7665:32;;-1:-1:-1;;7709:16:1;;;7706:36;;;7738:1;7735;7728:12;7706:36;;7761:63;7816:7;7805:8;7794:9;7790:24;7761:63;:::i;:::-;7751:73;;;6622:1208;;;;;:::o;7835:439::-;7888:3;7926:5;7920:12;7953:6;7948:3;7941:19;7979:4;8008;8003:3;7999:14;7992:21;;8047:4;8040:5;8036:16;8070:1;8080:169;8094:6;8091:1;8088:13;8080:169;;;8155:13;;8143:26;;8189:12;;;;8224:15;;;;8116:1;8109:9;8080:169;;;-1:-1:-1;8265:3:1;;7835:439;-1:-1:-1;;;;;7835:439:1:o;8279:261::-;8458:2;8447:9;8440:21;8421:4;8478:56;8530:2;8519:9;8515:18;8507:6;8478:56;:::i;8545:118::-;8631:5;8624:13;8617:21;8610:5;8607:32;8597:60;;8653:1;8650;8643:12;8668:315;8733:6;8741;8794:2;8782:9;8773:7;8769:23;8765:32;8762:52;;;8810:1;8807;8800:12;8762:52;8833:29;8852:9;8833:29;:::i;:::-;8823:39;;8912:2;8901:9;8897:18;8884:32;8925:28;8947:5;8925:28;:::i;:::-;8972:5;8962:15;;;8668:315;;;;;:::o;8988:186::-;9047:6;9100:2;9088:9;9079:7;9075:23;9071:32;9068:52;;;9116:1;9113;9106:12;9068:52;9139:29;9158:9;9139:29;:::i;9179:260::-;9247:6;9255;9308:2;9296:9;9287:7;9283:23;9279:32;9276:52;;;9324:1;9321;9314:12;9276:52;9347:29;9366:9;9347:29;:::i;:::-;9337:39;;9395:38;9429:2;9418:9;9414:18;9395:38;:::i;:::-;9385:48;;9179:260;;;;;:::o;9444:606::-;9548:6;9556;9564;9572;9580;9633:3;9621:9;9612:7;9608:23;9604:33;9601:53;;;9650:1;9647;9640:12;9601:53;9673:29;9692:9;9673:29;:::i;:::-;9663:39;;9721:38;9755:2;9744:9;9740:18;9721:38;:::i;:::-;9711:48;;9806:2;9795:9;9791:18;9778:32;9768:42;;9857:2;9846:9;9842:18;9829:32;9819:42;;9912:3;9901:9;9897:19;9884:33;-1:-1:-1;;;;;9932:6:1;9929:30;9926:50;;;9972:1;9969;9962:12;9926:50;9995:49;10036:7;10027:6;10016:9;10012:22;9995:49;:::i;10055:380::-;10134:1;10130:12;;;;10177;;;10198:61;;10252:4;10244:6;10240:17;10230:27;;10198:61;10305:2;10297:6;10294:14;10274:18;10271:38;10268:161;;10351:10;10346:3;10342:20;10339:1;10332:31;10386:4;10383:1;10376:15;10414:4;10411:1;10404:15;10268:161;;10055:380;;;:::o;10566:518::-;10668:2;10663:3;10660:11;10657:421;;;10704:5;10701:1;10694:16;10748:4;10745:1;10735:18;10818:2;10806:10;10802:19;10799:1;10795:27;10789:4;10785:38;10854:4;10842:10;10839:20;10836:47;;;-1:-1:-1;10877:4:1;10836:47;10932:2;10927:3;10923:12;10920:1;10916:20;10910:4;10906:31;10896:41;;10987:81;11005:2;10998:5;10995:13;10987:81;;;11064:1;11050:16;;11031:1;11020:13;10987:81;;11260:1345;11386:3;11380:10;-1:-1:-1;;;;;11405:6:1;11402:30;11399:56;;;11435:18;;:::i;:::-;11464:97;11554:6;11514:38;11546:4;11540:11;11514:38;:::i;:::-;11508:4;11464:97;:::i;:::-;11616:4;;11673:2;11662:14;;11690:1;11685:663;;;;12392:1;12409:6;12406:89;;;-1:-1:-1;12461:19:1;;;12455:26;12406:89;-1:-1:-1;;11217:1:1;11213:11;;;11209:24;11205:29;11195:40;11241:1;11237:11;;;11192:57;12508:81;;11655:944;;11685:663;10513:1;10506:14;;;10550:4;10537:18;;-1:-1:-1;;11721:20:1;;;11839:236;11853:7;11850:1;11847:14;11839:236;;;11942:19;;;11936:26;11921:42;;12034:27;;;;12002:1;11990:14;;;;11869:19;;11839:236;;;11843:3;12103:6;12094:7;12091:19;12088:201;;;12164:19;;;12158:26;-1:-1:-1;;12247:1:1;12243:14;;;12259:3;12239:24;12235:37;12231:42;12216:58;12201:74;;12088:201;-1:-1:-1;;;;;12335:1:1;12319:14;;;12315:22;12302:36;;-1:-1:-1;11260:1345:1:o;12610:127::-;12671:10;12666:3;12662:20;12659:1;12652:31;12702:4;12699:1;12692:15;12726:4;12723:1;12716:15;12742:128;12809:9;;;12830:11;;;12827:37;;;12844:18;;:::i;12875:127::-;12936:10;12931:3;12927:20;12924:1;12917:31;12967:4;12964:1;12957:15;12991:4;12988:1;12981:15;13007:168;13080:9;;;13111;;13128:15;;;13122:22;;13108:37;13098:71;;13149:18;;:::i;13180:127::-;13241:10;13236:3;13232:20;13229:1;13222:31;13272:4;13269:1;13262:15;13296:4;13293:1;13286:15;13312:120;13352:1;13378;13368:35;;13383:18;;:::i;:::-;-1:-1:-1;13417:9:1;;13312:120::o;13437:723::-;13487:3;13528:5;13522:12;13557:36;13583:9;13557:36;:::i;:::-;13612:1;13629:17;;;13655:133;;;;13802:1;13797:357;;;;13622:532;;13655:133;-1:-1:-1;;13688:24:1;;13676:37;;13761:14;;13754:22;13742:35;;13733:45;;;-1:-1:-1;13655:133:1;;13797:357;13828:5;13825:1;13818:16;13857:4;13902;13899:1;13889:18;13929:1;13943:165;13957:6;13954:1;13951:13;13943:165;;;14035:14;;14022:11;;;14015:35;14078:16;;;;13972:10;;13943:165;;;13947:3;;;14137:6;14132:3;14128:16;14121:23;;13622:532;;;;;13437:723;;;;:::o;14165:389::-;14341:3;14369:38;14403:3;14395:6;14369:38;:::i;:::-;14436:6;14430:13;14452:65;14510:6;14506:2;14499:4;14491:6;14487:17;14452:65;:::i;:::-;14533:15;;14165:389;-1:-1:-1;;;;14165:389:1:o;14746:1430::-;-1:-1:-1;;;15339:59:1;;15421:13;;15321:3;;15443:75;15421:13;15506:2;15497:12;;15490:4;15478:17;;15443:75;:::i;:::-;-1:-1:-1;;;15577:2:1;15537:16;;;15569:11;;;15562:67;15654:13;;15676:76;15654:13;15738:2;15730:11;;15723:4;15711:17;;15676:76;:::i;:::-;15817:66;15812:2;15771:17;;;;15804:11;;;15797:87;-1:-1:-1;;;15908:2:1;15900:11;;15893:65;15977:46;16019:2;16011:11;;16003:6;15977:46;:::i;:::-;15967:56;;16054:6;16048:13;16070:67;16128:8;16124:2;16117:4;16109:6;16105:17;16070:67;:::i;:::-;16153:17;;14746:1430;-1:-1:-1;;;;;;14746:1430:1:o;16181:1107::-;16693:29;16688:3;16681:42;16663:3;16752:6;16746:13;16768:75;16836:6;16831:2;16826:3;16822:12;16815:4;16807:6;16803:17;16768:75;:::i;:::-;16907:66;16902:2;16862:16;;;16894:11;;;16887:87;-1:-1:-1;;;16998:2:1;16990:11;;16983:63;17071:13;;17093:76;17071:13;17155:2;17147:11;;17140:4;17128:17;;17093:76;:::i;:::-;-1:-1:-1;;;17229:2:1;17188:17;;;;17221:11;;;17214:41;17279:2;17271:11;;16181:1107;-1:-1:-1;;;;16181:1107:1:o;17896:125::-;17961:9;;;17982:10;;;17979:36;;;17995:18;;:::i;18026:465::-;18283:2;18272:9;18265:21;18246:4;18309:56;18361:2;18350:9;18346:18;18338:6;18309:56;:::i;:::-;18413:9;18405:6;18401:22;18396:2;18385:9;18381:18;18374:50;18441:44;18478:6;18470;18441:44;:::i;:::-;18433:52;18026:465;-1:-1:-1;;;;;18026:465:1:o;18906:135::-;18945:3;18966:17;;;18963:43;;18986:18;;:::i;:::-;-1:-1:-1;19033:1:1;19022:13;;18906:135::o;19046:112::-;19078:1;19104;19094:35;;19109:18;;:::i;:::-;-1:-1:-1;19143:9:1;;19046:112::o;20541:245::-;20608:6;20661:2;20649:9;20640:7;20636:23;20632:32;20629:52;;;20677:1;20674;20667:12;20629:52;20709:9;20703:16;20728:28;20750:5;20728:28;:::i;20791:561::-;-1:-1:-1;;;;;21088:15:1;;;21070:34;;21140:15;;21135:2;21120:18;;21113:43;21187:2;21172:18;;21165:34;;;21230:2;21215:18;;21208:34;;;21050:3;21273;21258:19;;21251:32;;;21013:4;;21300:46;;21326:19;;21318:6;21300:46;:::i;:::-;21292:54;20791:561;-1:-1:-1;;;;;;;20791:561:1:o;21357:249::-;21426:6;21479:2;21467:9;21458:7;21454:23;21450:32;21447:52;;;21495:1;21492;21485:12;21447:52;21527:9;21521:16;21546:30;21570:5;21546:30;:::i;21611:179::-;21646:3;21688:1;21670:16;21667:23;21664:120;;;21734:1;21731;21728;21713:23;-1:-1:-1;21771:1:1;21765:8;21760:3;21756:18;21664:120;21611:179;:::o;21795:671::-;21834:3;21876:4;21858:16;21855:26;21852:39;;;21795:671;:::o;21852:39::-;21918:2;21912:9;-1:-1:-1;;21983:16:1;21979:25;;21976:1;21912:9;21955:50;22034:4;22028:11;22058:16;-1:-1:-1;;;;;22164:2:1;22157:4;22149:6;22145:17;22142:25;22137:2;22129:6;22126:14;22123:45;22120:58;;;22171:5;;;;;21795:671;:::o;22120:58::-;22208:6;22202:4;22198:17;22187:28;;22244:3;22238:10;22271:2;22263:6;22260:14;22257:27;;;22277:5;;;;;;21795:671;:::o;22257:27::-;22361:2;22342:16;22336:4;22332:27;22328:36;22321:4;22312:6;22307:3;22303:16;22299:27;22296:69;22293:82;;;22368:5;;;;;;21795:671;:::o;22293:82::-;22384:57;22435:4;22426:6;22418;22414:19;22410:30;22404:4;22384:57;:::i;:::-;-1:-1:-1;22457:3:1;;21795:671;-1:-1:-1;;;;;21795:671:1:o;22471:489::-;-1:-1:-1;;;;;22740:15:1;;;22722:34;;22792:15;;22787:2;22772:18;;22765:43;22839:2;22824:18;;22817:34;;;22887:3;22882:2;22867:18;;22860:31;;;22665:4;;22908:46;;22934:19;;22926:6;22908:46;:::i;:::-;22900:54;22471:489;-1:-1:-1;;;;;;22471:489:1:o;22965:827::-;-1:-1:-1;;;;;23362:15:1;;;23344:34;;23414:15;;23409:2;23394:18;;23387:43;23324:3;23461:2;23446:18;;23439:31;;;23287:4;;23493:57;;23530:19;;23522:6;23493:57;:::i;:::-;23598:9;23590:6;23586:22;23581:2;23570:9;23566:18;23559:50;23632:44;23669:6;23661;23632:44;:::i;:::-;23618:58;;23725:9;23717:6;23713:22;23707:3;23696:9;23692:19;23685:51;23753:33;23779:6;23771;23753:33;:::i;:::-;23745:41;22965:827;-1:-1:-1;;;;;;;;22965:827:1:o

Swarm Source

ipfs://0d9095308341802128db3aff935bdbd095f9b7124e968a65e54b8074087e4a2f

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