Token

ERC-20: Rise (Rise)

ERC-721

Overview

Max Total Supply

2,888 Rise

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x1fa66c4d6665b3ac7ff11115d2864e0045c47565

Filtered by Token Holder

0x83D8F8c4A7a2C9F4099bc1c2eFAeBd75D8E9794A

Balance

10 Rise

0x83d8f8c4a7a2c9f4099bc1c2efaebd75d8e9794a

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Rise

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-13
*/

// 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 IERC31337 {
    /**
     * 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 ERC404a is Context, ERC165, IERC1155, IERC1155MetadataURI, IERC31337, 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 of burnt tokens
    LibBitmap.Bitmap internal _burnt;
    
    // 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 account => mapping(address spender => 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);
    }

    /**
     * @dev Returns if 1155 events are enabled.
     * Override or change to true for 1155 flag on etherscan.
     * In 1155 mode Etherscan ignores CA reported balances and incorrectly 
     * calculates wallet balances
     */
    function erc1155Enabled() internal pure virtual returns (bool) {
        return false;
    }

    /** @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(IERC31337).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`.
            )
        }

        if(erc1155Enabled())
            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))))
            }
        }

        if(erc1155Enabled())
            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)
            }
        }

        if(erc1155Enabled())
            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) || _burnt.get(id)) {
            revert BurnFromNonOnwerAddress();
        }

        //_owned[from].unset(id);
        _burnt.set(id);

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

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

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

    /**
     * @dev Destroys tokens of token types in `ids` from `from`
     * UNUSED - see next implementation
     * 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))))
            }
        }
        
        if(erc1155Enabled())
            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(erc1155Enabled()) {
            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 Rise is ERC404a {
    using Strings for uint256;
    string public dataURI;
    string public baseTokenURI;
    
    uint8 private constant _decimals = 18;
    uint256 private constant _totalTokens = 2888;
    uint256 private constant _tokensPerNFT = 1;
    string private constant _name = "Rise";
    string private constant _ticker = "Rise";

    bool private _revealMode = false;
    string public placeholderURI;
    mapping(uint256 => uint256) private _revealBlocks;
    mapping(uint256 => bytes32) private _revealSeeds;
    uint256 public singleReveal;
    bytes32 public singleRevealed;

    uint256 public maxWallet;
    bool public transferDelay = true;
    mapping (address => uint256) private delayTimer;

    constructor() ERC404a("", _name, _ticker, _decimals, _totalTokens, _tokensPerNFT) {
        placeholderURI = "https://rise404.com/uploads/2024/02/";
        maxWallet = (_totalTokens * 10 ** _decimals) * 4 / 100;
        whitelist[0xb27308f9F90D607463bb33eA1BeBb41C27CE5AB6] = true;
        whitelist[0xE592427A0AEce92De3Edee1F18E0157C05861564] = true;
        singleReveal = block.number + 2;
    }

    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, "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 setPlaceholderURI(string memory _placeholderURI) public onlyOwner {
        placeholderURI = _placeholderURI;
    }

    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;
            bytes32 rs;
            
            if(_revealMode) { 
                rs = _revealSeeds[id];
                if(rs == 0){
                    seed = uint8(bytes1(keccak256(abi.encodePacked(singleRevealed, id))));
                } else
                    seed = uint8(bytes1(rs));
            }
            else {
                seed = uint8(bytes1(keccak256(abi.encodePacked(id))));
            }

                string memory color;
                string memory description = "A new rise for 404 - the most gas efficient ERC 404, the first industry standard 2888 3D rendered NFT supply collection.";

                if ((!_revealMode && bytes(placeholderURI).length > 0) || (_revealMode && rs == 0 && singleReveal == 0))
                    color = "4-3-vid";
                else if (seed <= 5) {
                    color = "Diamond";
                } else if (seed <= 17) {
                    color = "Gold";
                } else if (seed <= 32) {
                    color = "Red";
                } else if (seed <= 52) {
                    color = "Blue";
                } else if (seed <= 75) {
                    color = "Pink";
                } else if (seed <= 100) {
                    color = "Orange";
                } else if (seed <= 126) {
                    color = "Green";
                } else if (seed <= 156) {
                    color = "Yellow";
                } else if (seed <= 199) {
                    color = "White";
                } else if (seed <= 255) {
                    color = "Purple";
                }

                string memory imgURL;
                if (bytes(placeholderURI).length > 0 )
                    imgURL = placeholderURI;
                else
                    imgURL = dataURI;

                string memory jsonPreImage = string(abi.encodePacked('{"name": "', color,' Dawn #', id.toString(), '","description":"', description, '","external_url":"https://rise404.com","image":"', imgURL, color, '.jpg", "animation_url":"', imgURL, color, '.mp4'));
                return string(abi.encodePacked("data:application/json;utf8,", jsonPreImage, '","attributes":[{"trait_type":"Color","value":"', color, '"}]}'));
            
        }
    }

    function prepReveal(uint256 id) external {
        require(_revealMode, "No need to run");
        require(isOwnerOf(msg.sender, id), "Must own NFT");
        require(_revealBlocks[id] == 0 || (block.number - _revealBlocks[id] > 250 && _revealSeeds[id] == 0), "Already revealed");

        _revealBlocks[id] = block.number + 2;
    }

    function reveal(uint256 id) external {
        uint256 rb = _revealBlocks[id];
        require(_revealMode, "No need to run");
        require(isOwnerOf(msg.sender, id), "Must own NFT");
        require(rb > 0 && block.number > rb, "Not ready");
        require(_revealSeeds[id] == 0, "Already revealed");

        _revealSeeds[id] = keccak256(abi.encodePacked(blockhash(rb-1), rb, blockhash(rb-2), id));
    }

    function singlePrep() external onlyOwner {
        require(singleReveal == 0 || (block.number - singleReveal > 250 && singleRevealed == 0), "Already revealed");
        singleReveal = block.number + 2;
    }

    function singleFinal() external onlyOwner {
        require(singleReveal > 0 && block.number > singleReveal, "Not ready");
        singleRevealed = keccak256(abi.encodePacked(blockhash(singleReveal-1), singleReveal, blockhash(singleReveal-2)));
    }

    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":"placeholderURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"prepReveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"reveal","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":"_placeholderURI","type":"string"}],"name":"setPlaceholderURI","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":[],"name":"singleFinal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"singlePrep","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"singleReveal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"singleRevealed","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

75109:6562:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;46580:318;;;;;;:::i;:::-;;:::i;:::-;;;597:25:1;;;585:2;570:18;46580:318:0;;;;;;;;44784:531;;;;;;:::i;:::-;;:::i;:::-;;;1184:14:1;;1177:22;1159:41;;1147:2;1132:18;44784:531:0;1019:187:1;77536:91:0;;;;;;:::i;:::-;;:::i;:::-;;42058:18;;;:::i;:::-;;;;;;;:::i;41787:46::-;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;41787:46:0;;;;;;-1:-1:-1;;;;;3654:32:1;;;3636:51;;3624:2;3609:18;41787:46:0;3490:203:1;68218:483:0;;;;;;:::i;:::-;;:::i;75766:32::-;;;;;;;;;81299:253;;;:::i;81560:108::-;;;;;;:::i;:::-;;:::i;42230:36::-;;;;;77182:98;;;;;;:::i;:::-;;:::i;68850:827::-;;;;;;:::i;:::-;;:::i;46259:170::-;;;;;;:::i;:::-;;:::i;48621:418::-;;;;;;:::i;:::-;;:::i;42163:31::-;;;;;;;;6627:4:1;6615:17;;;6597:36;;6585:2;6570:18;42163:31:0;6455:184:1;77402:126:0;;;;;;:::i;:::-;;:::i;47064:530::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;76959:91::-;;;:::i;43745:119::-;;;;;;:::i;:::-;;:::i;42343:37::-;;;;;77058:116;;;;;;:::i;:::-;;:::i;42298:38::-;;;;;45917:114;;;;;;:::i;:::-;-1:-1:-1;;;;;46007:16:0;45980:7;46007:16;;;:9;:16;;;;;;;45917:114;2629:103;;;:::i;75517:28::-;;;:::i;74852:250::-;;;;;;:::i;:::-;;:::i;1954:87::-;2000:7;2027:6;-1:-1:-1;;;;;2027:6:0;1954:87;;42106:20;;;:::i;73136:1264::-;;;;;;:::i;:::-;;:::i;42426:41::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;42553:29;;;;;;47667:155;;;;;;:::i;:::-;;:::i;67874:186::-;;;;;;:::i;:::-;;:::i;81081:210::-;;;:::i;80655:418::-;;;;;;:::i;:::-;;:::i;80308:339::-;;;;;;:::i;:::-;;:::i;44572:140::-;;;;;;:::i;:::-;;:::i;77635:2665::-;;;;;;:::i;:::-;;:::i;75201:26::-;;;:::i;75697:29::-;;;;;;68068:142;;;;;;:::i;:::-;-1:-1:-1;;;;;68175:18:0;;;68148:7;68175:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;68068:142;77288:106;;;;;;:::i;:::-;;:::i;47894:168::-;;;;;;:::i;:::-;-1:-1:-1;;;;;48017:27:0;;;47993:4;48017:27;;;:18;:27;;;;;;;;:37;;;;;;;;;;;;;;;47894:168;75663:27;;;;;;48134:410;;;;;;:::i;:::-;;:::i;75173:21::-;;;:::i;2887:220::-;;;;;;:::i;:::-;;:::i;75735:24::-;;;;;;46580:318;46666:7;-1:-1:-1;;;;;46689:21:0;;46686:88;;46734:28;;-1:-1:-1;;;46734:28:0;;;;;;;;;;;46686:88;-1:-1:-1;;;;;46787:15:0;;;;;;:6;:15;;;;;;;;33712:1;33703:10;;;33692:22;;;;;;;;;33727:4;33719:12;;33692:40;33691:46;46784:104;;;-1:-1:-1;46834:1:0;46827:8;;46784:104;-1:-1:-1;46875:1:0;46784:104;46580:318;;;;:::o;44784:531::-;44886:4;-1:-1:-1;;;;;;44923:41:0;;-1:-1:-1;;;44923:41:0;;:110;;-1:-1:-1;;;;;;;44981:52:0;;-1:-1:-1;;;44981:52:0;44923:110;:169;;;-1:-1:-1;;;;;;;45050:42:0;;-1:-1:-1;;;45050:42:0;44923:169;:211;;;-1:-1:-1;;;;;;;;;;45109:25:0;;;44923:211;:288;;;-1:-1:-1;;;;;;;;;;45186:25:0;;;44923:288;:384;;;-1:-1:-1;;;;;;;;;;24026:40:0;;;45271:36;23917:157;77536:91;1840:13;:11;:13::i;:::-;77604:15:::1;77612:6;77604:7;:15::i;:::-;77536:91:::0;:::o;42058:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;68218:483::-;68291:4;68324:10;68357:14;44251:13;;;44177:95;68357:14;68349:5;:22;:35;;;;;68383:1;68375:5;:9;68349:35;68345:327;;;68407:23;68417:5;68424;68407:9;:23::i;:::-;68403:96;;68458:25;;-1:-1:-1;;;68458:25:0;;-1:-1:-1;;;;;3654:32:1;;68458:25:0;;;3636:51:1;3609:18;;68458:25:0;;;;;;;;68403:96;68515:18;;;;:11;:18;;;;;;;;;:28;;-1:-1:-1;;;;;;68515:28:0;-1:-1:-1;;;;;68515:28:0;;;;;;;;;68565:31;;597:25:1;;;68565:31:0;;;;;;570:18:1;68565:31:0;;;;;;;68345:327;;;68629:31;68638:5;68645:7;68654:5;68629:8;:31::i;:::-;-1:-1:-1;68689:4:0;;68218:483;-1:-1:-1;;;68218:483:0:o;81299:253::-;1840:13;:11;:13::i;:::-;81375:1:::1;81360:12;;:16;:47;;;;;81395:12;;81380;:27;81360:47;81352:69;;;::::0;-1:-1:-1;;;81352:69:0;;10846:2:1;81352:69:0::1;::::0;::::1;10828:21:1::0;10885:1;10865:18;;;10858:29;-1:-1:-1;;;10903:18:1;;;10896:39;10952:18;;81352:69:0::1;10644:332:1::0;81352:69:0::1;81499:1;81486:12;;:14;;;;:::i;:::-;81503:12;::::0;81476:25;::::1;::::0;81527:14:::1;81540:1;81503:12:::0;81527:14:::1;:::i;:::-;81459:84;::::0;;::::1;::::0;::::1;11431:19:1::0;;;;11466:12;;11459:28;;;;81517:25:0::1;11503:12:1::0;;;11496:28;11540:12;;81459:84:0::1;::::0;;-1:-1:-1;;81459:84:0;;::::1;::::0;;;;;;81449:95;;81459:84:::1;81449:95:::0;;::::1;::::0;81432:14:::1;:112:::0;81299:253::o;81560:108::-;81615:13;81648:12;81657:2;81648:8;:12::i;77182:98::-;1840:13;:11;:13::i;:::-;77254:7:::1;:18;77264:8:::0;77254:7;:18:::1;:::i;:::-;;77182:98:::0;:::o;68850:827::-;68937:4;68966:14;44251:13;;;44177:95;68966:14;68958:5;:22;68954:694;;;-1:-1:-1;;;;;69001:12:0;;;;;;:6;:12;;;;;;;;33712:1;33703:10;;;33692:22;;;;;;;;;33727:4;33719:12;;33692:40;33691:46;68997:96;;69052:25;;-1:-1:-1;;;69052:25:0;;-1:-1:-1;;;;;3654:32:1;;69052:25:0;;;3636:51:1;3609:18;;69052:25:0;3490:203:1;68997:96:0;69135:10;-1:-1:-1;;;;;69135:18:0;;;;;;:74;;-1:-1:-1;;;;;;48017:27:0;;47993:4;48017:27;;;:18;:27;;;;;;;;69198:10;48017:37;;;;;;;;;;69174:35;69135:74;:127;;;;-1:-1:-1;69244:18:0;;;;:11;:18;;;;;;-1:-1:-1;;;;;69244:18:0;69230:10;:32;;69135:127;69113:238;;;69304:31;;-1:-1:-1;;;69304:31:0;;69324:10;69304:31;;;3636:51:1;3609:18;;69304:31:0;3490:203:1;69113:238:0;69367:40;69377:4;69383:2;69387:12;69401:5;69367:9;:40::i;:::-;69431:18;;;;:11;:18;;;;;;;;69424:25;;-1:-1:-1;;;;;;69424:25:0;;;69466:48;;;;;;;;;;;;69484:4;;69490:2;;69443:5;;69424:25;;69466:17;:48::i;:::-;68954:694;;;69549:40;69565:4;69571:10;69583:5;69549:15;:40::i;:::-;69604:32;69614:4;69620:2;69624:5;69631:4;69604:9;:32::i;46259:170::-;46351:7;46378:43;46401:5;46408:12;46401:5;46408:4;:12;:::i;:::-;-1:-1:-1;;;;;46378:13:0;;;;;;:6;:13;;;;;;:43;:22;:43::i;:::-;46371:50;46259:170;-1:-1:-1;;;;46259:170:0:o;48621:418::-;-1:-1:-1;;;;;48837:20:0;;175:10;48837:20;;:60;;-1:-1:-1;48861:36:0;48878:4;175:10;47894:168;:::i;48861:36::-;48832:137;;48922:35;;-1:-1:-1;;;48922:35:0;;;;;;;;;;;48832:137;48979:52;49002:4;49008:2;49012:3;49017:7;49026:4;48979:22;:52::i;:::-;48621:418;;;;;:::o;77402:126::-;1840:13;:11;:13::i;:::-;77488:14:::1;:32;77505:15:::0;77488:14;:32:::1;:::i;47064:530::-:0;47220:16;47276:3;:10;47257:8;:15;:29;47254:90;;47310:22;;-1:-1:-1;;;47310:22:0;;;;;;;;;;;47254:90;47356:30;47403:8;:15;-1:-1:-1;;;;;47389:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;47389:30:0;;47356:63;;47437:9;47432:122;47456:8;:15;47452:1;:19;47432:122;;;47512:30;47522:8;47531:1;47522:11;;;;;;;;:::i;:::-;;;;;;;47535:3;47539:1;47535:6;;;;;;;;:::i;:::-;;;;;;;47512:9;:30::i;:::-;47493:13;47507:1;47493:16;;;;;;;;:::i;:::-;;;;;;;;;;:49;47473:3;;47432:122;;;-1:-1:-1;47573:13:0;47064:530;-1:-1:-1;;;47064:530:0:o;76959:91::-;1840:13;:11;:13::i;:::-;77029::::1;::::0;;-1:-1:-1;;77012:30:0;::::1;77029:13;::::0;;::::1;77028:14;77012:30;::::0;;76959:91::o;43745:119::-;1840:13;:11;:13::i;:::-;-1:-1:-1;;;;;43831:17:0;;;::::1;;::::0;;;:9:::1;:17;::::0;;;;:25;;-1:-1:-1;;43831:25:0::1;::::0;::::1;;::::0;;;::::1;::::0;;43745:119::o;77058:116::-;1840:13;:11;:13::i;:::-;77163:3:::1;77139:21;77153:7:::0;77139:11:::1;:21;:::i;:::-;:27;;;;:::i;:::-;77127:9;:39:::0;-1:-1:-1;77058:116:0:o;2629:103::-;1840:13;:11;:13::i;:::-;2694:30:::1;2721:1;2694:18;:30::i;:::-;2629:103::o:0;75517:28::-;;;;;;;:::i;74852:250::-;74919:16;74951:14;:12;:14::i;:::-;74969:1;74951:19;74948:74;;-1:-1:-1;;74994:16:0;;;75008:1;74994:16;;;;;;;;;74852:250::o;74948:74::-;75039:55;75055:5;44089:1;44251:13;;73136:1264;:::i;42106:20::-;;;;;;;:::i;73136:1264::-;73268:16;73335:4;73326:5;:13;73322:45;;73348:19;;-1:-1:-1;;;73348:19:0;;;;;;;;;;;73322:45;44089:1;73473:5;:23;73469:87;;;44089:1;73517:23;;73469:87;73635:17;73655:14;44251:13;;;44177:95;73655:14;73635:34;;73695:9;73688:4;:16;73684:73;;;73732:9;73725:16;;73684:73;73773:22;73821:4;73813:5;:12;73810:157;;;73863:29;73873:5;73880;73887:4;73863:9;:29::i;:::-;73846:46;;73810:157;;;-1:-1:-1;73950:1:0;73810:157;73995:25;74037:14;-1:-1:-1;;;;;74023:29:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74023:29:0;-1:-1:-1;;;;;;74101:13:0;;74069:29;74101:13;;;:6;:13;;;;;73995:57;;-1:-1:-1;74184:5:0;;74143:209;74210:14;74195:11;:29;74143:209;;33712:1;33703:10;;;33430;33692:22;;;;;;;;;;;33727:4;33719:12;;33692:40;33736:1;33691:46;74250:87;;;74316:1;74290:8;74299:13;;;;;;74290:23;;;;;;;;:::i;:::-;;;;;;:27;;;;;74250:87;74226:3;;;;;74143:209;;;-1:-1:-1;74373:8:0;;73136:1264;-1:-1:-1;;;;;;;;73136:1264:0:o;47667:155::-;47762:52;175:10;47795:8;47805;47762:18;:52::i;67874:186::-;67943:4;67976:10;67997:33;67976:10;68014:2;68018:5;68025:4;67997:9;:33::i;81081:210::-;1840:13;:11;:13::i;:::-;81141:12:::1;::::0;:17;;:79:::1;;;81193:3;81178:12;;81163;:27;;;;:::i;:::-;:33;:56;;;;-1:-1:-1::0;81200:14:0::1;::::0;:19;81163:56:::1;81133:108;;;;-1:-1:-1::0;;;81133:108:0::1;;;;;;;:::i;:::-;81267:16;:12;81282:1;81267:16;:::i;:::-;81252:12;:31:::0;81081:210::o;80655:418::-;80703:10;80716:17;;;:13;:17;;;;;;80752:11;;;;80744:38;;;;-1:-1:-1;;;80744:38:0;;14972:2:1;80744:38:0;;;14954:21:1;15011:2;14991:18;;;14984:30;-1:-1:-1;;;15030:18:1;;;15023:44;15084:18;;80744:38:0;14770:338:1;80744:38:0;80801:25;80811:10;80823:2;80801:9;:25::i;:::-;80793:50;;;;-1:-1:-1;;;80793:50:0;;15315:2:1;80793:50:0;;;15297:21:1;15354:2;15334:18;;;15327:30;-1:-1:-1;;;15373:18:1;;;15366:42;15425:18;;80793:50:0;15113:336:1;80793:50:0;80867:1;80862:2;:6;:27;;;;;80887:2;80872:12;:17;80862:27;80854:49;;;;-1:-1:-1;;;80854:49:0;;10846:2:1;80854:49:0;;;10828:21:1;10885:1;10865:18;;;10858:29;-1:-1:-1;;;10903:18:1;;;10896:39;10952:18;;80854:49:0;10644:332:1;80854:49:0;80922:16;;;;:12;:16;;;;;;:21;80914:50;;;;-1:-1:-1;;;80914:50:0;;;;;;;:::i;:::-;81033:4;81036:1;81033:2;:4;:::i;:::-;81023:15;81040:2;81054:4;81057:1;81040:2;81054:4;:::i;:::-;81006:58;;;;;;15667:19:1;;;;15702:12;;15695:28;;;;81044:15:0;15739:12:1;;;15732:28;15776:12;;;15769:28;;;15813:13;;81006:58:0;;;-1:-1:-1;;81006:58:0;;;;;;;;;80996:69;;81006:58;80996:69;;;;80977:16;;;;:12;:16;;;;;;:88;;;;-1:-1:-1;80655:418:0:o;80308:339::-;80368:11;;;;80360:38;;;;-1:-1:-1;;;80360:38:0;;14972:2:1;80360:38:0;;;14954:21:1;15011:2;14991:18;;;14984:30;-1:-1:-1;;;15030:18:1;;;15023:44;15084:18;;80360:38:0;14770:338:1;80360:38:0;80417:25;80427:10;80439:2;80417:9;:25::i;:::-;80409:50;;;;-1:-1:-1;;;80409:50:0;;15315:2:1;80409:50:0;;;15297:21:1;15354:2;15334:18;;;15327:30;-1:-1:-1;;;15373:18:1;;;15366:42;15425:18;;80409:50:0;15113:336:1;80409:50:0;80478:17;;;;:13;:17;;;;;;:22;;:91;;-1:-1:-1;80520:17:0;;;;:13;:17;;;;;;80540:3;;80505:32;;:12;:32;:::i;:::-;:38;:63;;;;-1:-1:-1;80547:16:0;;;;:12;:16;;;;;;:21;80505:63;80470:120;;;;-1:-1:-1;;;80470:120:0;;;;;;;:::i;:::-;80623:16;:12;80638:1;80623:16;:::i;:::-;80603:17;;;;:13;:17;;;;;;:36;80308:339::o;44572:140::-;-1:-1:-1;;;;;44681:15:0;;44657:4;44681:15;;;:6;:15;;;;;;;;33712:1;33703:10;;;33692:22;;;;;;;;33727:4;33719:12;;33692:40;33691:46;44681:23;44674:30;44572:140;-1:-1:-1;;;44572:140:0:o;77635:2665::-;77686:13;77721:14;44251:13;;;44177:95;77721:14;77715:2;:20;77712:54;;77744:22;;-1:-1:-1;;;77744:22:0;;;;;;;;;;;77712:54;77813:1;77789:13;77799:2;77789:9;:13::i;:::-;77783:27;:31;77779:70;;;77836:13;77846:2;77836:9;:13::i;77779:70::-;77893:1;77870:12;77864:26;;;;;:::i;:::-;;;:30;77860:2433;;;77940:12;77954:13;:2;:11;:13::i;:::-;77923:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;77909:60;;77635:2665;;;:::o;77860:2433::-;78067:11;;78000:10;;;;78067:11;;78064:373;;;-1:-1:-1;78105:16:0;;;;:12;:16;;;;;;;78143:7;;;78140:174;;78221:14;;78204:36;;;;;;17223:19:1;;;;17258:12;;17251:28;;;17295:12;;78204:36:0;;;;;;;;;;;;78194:47;;;;;;78181:62;;78174:69;;78064:373;;78140:174;78310:2;78297:17;;78290:24;;78064:373;;;78398:20;;;;;;17447:19:1;;;17482:12;78398:20:0;;;;;;;;;;;;78388:31;;;;;;78375:46;;78368:53;;78064:373;78457:19;78495:25;:150;;;;;;;;;;;;;;;;;78672:11;;78495:150;;-1:-1:-1;78672:11:0;;78671:12;:48;;;;;78718:1;78693:14;78687:28;;;;;:::i;:::-;;;:32;78671:48;78670:99;;;-1:-1:-1;78725:11:0;;;;:22;;;;-1:-1:-1;78740:7:0;;78725:22;:43;;;;-1:-1:-1;78751:12:0;;:17;78725:43;78666:965;;;78792:17;;;;;;;;;;;;;-1:-1:-1;;;78792:17:0;;;;;78666:965;;;78845:1;78837:4;:9;;;78833:798;;78871:17;;;;;;;;;;;;;-1:-1:-1;;;78871:17:0;;;;;78833:798;;;78926:2;78918:4;:10;;;78914:717;;78953:14;;;;;;;;;;;;;-1:-1:-1;;;78953:14:0;;;;;78914:717;;;79005:2;78997:4;:10;;;78993:638;;79032:13;;;;;;;;;;;;;-1:-1:-1;;;79032:13:0;;;;;78993:638;;;79083:2;79075:4;:10;;;79071:560;;79110:14;;;;;;;;;;;;;-1:-1:-1;;;79110:14:0;;;;;79071:560;;;79162:2;79154:4;:10;;;79150:481;;79189:14;;;;;;;;;;;;;-1:-1:-1;;;79189:14:0;;;;;79150:481;;;79241:3;79233:4;:11;;;79229:402;;79269:16;;;;;;;;;;;;;-1:-1:-1;;;79269:16:0;;;;;79229:402;;;79323:3;79315:4;:11;;;79311:320;;79351:15;;;;;;;;;;;;;-1:-1:-1;;;79351:15:0;;;;;79311:320;;;79404:3;79396:4;:11;;;79392:239;;79432:16;;;;;;;;;;;;;-1:-1:-1;;;79432:16:0;;;;;79392:239;;;79486:3;79478:4;:11;;;79474:157;;79514:15;;;;;;;;;;;;;-1:-1:-1;;;79514:15:0;;;;;79474:157;;;79567:3;79559:4;:11;;;79555:76;;79595:16;;;;;;;;;;;;;-1:-1:-1;;;79595:16:0;;;;;79555:76;79651:20;79725:1;79700:14;79694:28;;;;;:::i;:::-;;;:32;79690:144;;;79759:14;79750:23;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79690:144;;;79827:7;79818:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;79690:144;79855:26;79922:5;79939:13;:2;:11;:13::i;:::-;79975:11;80040:6;80048:5;80083:6;80091:5;79891:214;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;79855:251;;80187:12;80252:5;80139:127;;;;;;;;;:::i;:::-;;;;;;;;;;;;;80125:142;;;;;;;;77635:2665;;;:::o;77860:2433::-;77635:2665;;;:::o;75201:26::-;;;;;;;:::i;77288:106::-;1840:13;:11;:13::i;:::-;77362:12:::1;:24;77377:9:::0;77362:12;:24:::1;:::i;48134:410::-:0;-1:-1:-1;;;;;48323:20:0;;175:10;48323:20;;:60;;-1:-1:-1;48347:36:0;48364:4;175:10;47894:168;:::i;48347:36::-;48320:217;;;48399:51;48417:4;48423:2;48427;48431:6;48439:4;48445;48399:17;:51::i;:::-;48320:217;;;48490:35;;-1:-1:-1;;;48490:35:0;;;;;;;;;;;75173:21;;;;;;;:::i;2887:220::-;1840:13;:11;:13::i;:::-;-1:-1:-1;;;;;2972:22:0;::::1;2968:93;;3018:31;::::0;-1:-1:-1;;;3018:31:0;;3046:1:::1;3018:31;::::0;::::1;3636:51:1::0;3609:18;;3018:31:0::1;3490:203:1::0;2968:93:0::1;3071:28;3090:8;3071:18;:28::i;2119:166::-:0;2000:7;2027:6;-1:-1:-1;;;;;2027:6:0;175:10;2179:23;2175:103;;2226:40;;-1:-1:-1;;;2226:40:0;;175:10;2226:40;;;3636:51:1;3609:18;;2226:40:0;3490:203:1;55171:88:0;55238:4;:13;55245:6;55238:4;:13;:::i;71666:130::-;71751:37;71760:5;71767:7;71776:5;71783:4;71751:8;:37::i;:::-;71666:130;;;:::o;69685:325::-;-1:-1:-1;;;;;69780:18:0;;69776:88;;69822:30;;-1:-1:-1;;;69822:30:0;;69849:1;69822:30;;;3636:51:1;3609:18;;69822:30:0;3490:203:1;69776:88:0;-1:-1:-1;;;;;69878:16:0;;69874:88;;69918:32;;-1:-1:-1;;;69918:32:0;;69947:1;69918:32;;;3636:51:1;3609:18;;69918:32:0;3490:203:1;69874:88:0;69972:30;69980:4;69986:2;69990:5;69997:4;69972:7;:30::i;:::-;69685:325;;;;:::o;49538:1624::-;-1:-1:-1;;;;;49742:16:0;;49739:78;;49782:23;;-1:-1:-1;;;49782:23:0;;;;;;;;;;;49739:78;175:10;49829:16;49894:21;49912:2;49894:17;:21::i;:::-;49871:44;;49989:6;49999:1;49989:11;:35;;;;-1:-1:-1;;;;;;50004:12:0;;;;;;:6;:12;;;;;;;;33712:1;33703:10;;;33692:22;;;;;;;;;33727:4;33719:12;;33692:40;33691:46;50004:20;49986:260;;;-1:-1:-1;;;;;50041:12:0;;;;;;;:6;:12;;;;;;;;34204:1;34195:10;;;34184:22;;;;;;;;;:48;;34226:4;34218:12;;34212:19;;;34210:22;;34184:48;;;;;;50078:10;;;;;;;;;;;33985:22;;;;;;;;:47;;;;;;;;50111:40;;50041:12;;50078:10;;50131:12;;50111:9;:40::i;:::-;49986:260;;;50191:43;;-1:-1:-1;;;50191:43:0;;;;;;;;;;;49986:260;-1:-1:-1;;;;;50444:25:0;;;;50497:27;;50850:6;50444:25;50497:27;-1:-1:-1;;;;;;;;;;;50258:16:0;;50581:304;51006:44;51026:8;51036:4;51042:2;51046:3;51006:19;:44::i;:::-;51066:5;51063:91;;;51086:68;51117:8;51127:4;51133:2;51137;51141:6;51149:4;51086:30;:68::i;:::-;49728:1434;;;;49538:1624;;;;;;:::o;72255:487::-;-1:-1:-1;;;;;68175:18:0;;;72355:24;68175:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;-1:-1:-1;;72422:37:0;;72418:317;;72499:5;72480:16;:24;72476:132;;;72532:60;;-1:-1:-1;;;72532:60:0;;-1:-1:-1;;;;;21560:32:1;;72532:60:0;;;21542:51:1;21609:18;;;21602:34;;;21652:18;;;21645:34;;;21515:18;;72532:60:0;21340:345:1;72476:132:0;72651:57;72660:5;72667:7;72695:5;72676:16;:24;72702:5;72651:8;:57::i;38455:786::-;38577:13;38659:1;38650:10;;;38699:4;38691:12;;38741:3;38724:14;;;:20;38718:417;;38790:10;:18;;;;;;;;;;;38774:44;;38790:27;;38774:15;:44::i;:::-;38868:14;;38936:4;38917:23;;;38868:14;-1:-1:-1;38992:8:0;;;;38837:17;;38887:1;38867:21;38857:32;38987:133;39012:9;39002:6;:19;38987:133;;39081:10;:18;;;;;;;;;;;39065:35;;:15;:35::i;:::-;39056:44;;;;39023:8;;;;;38987:133;;;38747:388;38718:417;39175:10;:18;;;;;;;;;;;39158:64;;39175:27;;39208:3;:12;;;39174:47;39158:15;:64::i;:::-;39149:73;;;;38455:786;-1:-1:-1;;;;;38455:786:0:o;51520:2807::-;51742:7;:14;51728:3;:10;:28;51725:89;;51780:22;;-1:-1:-1;;;51780:22:0;;;;;;;;;;;51725:89;-1:-1:-1;;;;;51829:16:0;;51826:78;;51869:23;;-1:-1:-1;;;51869:23:0;;;;;;;;;;;51826:78;175:10;51914:16;52016:370;52040:3;:10;52036:1;:14;52016:370;;;52072:10;52085:3;52089:1;52085:6;;;;;;;;:::i;:::-;;;;;;;52072:19;;52106:14;52123:7;52131:1;52123:10;;;;;;;;:::i;:::-;;;;;;;52106:27;;52153:6;52163:1;52153:11;:35;;;;-1:-1:-1;;;;;;52168:12:0;;;;;;:6;:12;;;;;;;;33712:1;33703:10;;;33692:22;;;;;;;;;33727:4;33719:12;;33692:40;33691:46;52168:20;52150:225;;;-1:-1:-1;;;;;;52209:12:0;;;;;;;:6;:12;;;;;;;;34204:1;34195:10;;;34184:22;;;;;;;;;:48;;34226:4;34218:12;;;34212:19;;;34210:22;;34184:48;;;;;52250:10;;;;;;;;;;;33985:22;;;;;;;;;:47;;;;;;;;52052:3;52016:370;;;;52396:53;52406:4;52412:2;52431:3;:10;52416:12;:25;;;;:::i;:::-;52443:5;52396:9;:53::i;:::-;52462:16;52489:18;52518:11;52532:3;:10;52545:1;52532:14;;;;:::i;:::-;52518:28;;-1:-1:-1;;;;;53029:4:0;53025:27;53011:41;;-1:-1:-1;;;;;53082:2:0;53078:25;53066:37;;53444:4;53439:3;53435:14;53429:21;53393:8;53353:10;-1:-1:-1;;;;;;;;;;;53240:1:0;53183;53160:319;53767:1;53729:336;53803:3;53794:7;53791:16;53729:336;;54039:7;54033:4;54029:18;54024:3;54020:28;54014:35;54004:8;53992:10;-1:-1:-1;;;;;;;;;;;53962:1:0;53959;53954:96;53852:1;53839:15;53729:336;;;-1:-1:-1;54187:44:0;54207:8;54217:4;54223:2;54227:3;54187:19;:44::i;:::-;54244:75;54280:8;54290:4;54296:2;54300:3;54305:7;54314:4;54244:35;:75::i;:::-;51714:2613;;;;51520:2807;;;;;:::o;3267:191::-;3341:16;3360:6;;-1:-1:-1;;;;;3377:17:0;;;-1:-1:-1;;;;;;3377:17:0;;;;;;3410:40;;3360:6;;;;;;;3410:40;;3341:16;3410:40;3330:128;3267:191;:::o;44370:114::-;44417:7;44089:1;44251:13;;44444:32;;;;:::i;:::-;44437:39;;44370:114;:::o;62935:331::-;63090:8;-1:-1:-1;;;;;63081:17:0;:5;-1:-1:-1;;;;;63081:17:0;;63073:71;;;;-1:-1:-1;;;63073:71:0;;22362:2:1;63073:71:0;;;22344:21:1;22401:2;22381:18;;;22374:30;22440:34;22420:18;;;22413:62;-1:-1:-1;;;22491:18:1;;;22484:39;22540:19;;63073:71:0;22160:405:1;63073:71:0;-1:-1:-1;;;;;63155:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;63155:46:0;;;;;;;;;;63217:41;;1159::1;;;63217::0;;1132:18:1;63217:41:0;;;;;;;62935:331;;;:::o;45726:105::-;45786:13;45819:4;45812:11;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45726:105;;;:::o;12990:723::-;13046:13;13267:5;13276:1;13267:10;13263:53;;-1:-1:-1;;13294:10:0;;;;;;;;;;;;-1:-1:-1;;;13294:10:0;;;;;12990:723::o;13263:53::-;13341:5;13326:12;13382:78;13389:9;;13382:78;;13415:8;;;;:::i;:::-;;-1:-1:-1;13438:10:0;;-1:-1:-1;13446:2:0;13438:10;;:::i;:::-;;;13382:78;;;13470:19;13502:6;-1:-1:-1;;;;;13492:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;13492:17:0;;13470:39;;13520:154;13527:10;;13520:154;;13554:11;13564:1;13554:11;;:::i;:::-;;-1:-1:-1;13623:10:0;13631:2;13623:5;:10;:::i;:::-;13610:24;;:2;:24;:::i;:::-;13597:39;;13580:6;13587;13580:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;13580:56:0;;;;;;;;-1:-1:-1;13651:11:0;13660:2;13651:11;;:::i;:::-;;;13520:154;;71804:443;-1:-1:-1;;;;;71917:19:0;;71913:91;;71960:32;;-1:-1:-1;;;71960:32:0;;71989:1;71960:32;;;3636:51:1;3609:18;;71960:32:0;3490:203:1;71913:91:0;-1:-1:-1;;;;;72018:21:0;;72014:92;;72063:31;;-1:-1:-1;;;72063:31:0;;72091:1;72063:31;;;3636:51:1;3609:18;;72063:31:0;3490:203:1;72014:92:0;-1:-1:-1;;;;;72116:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;:35;;;72162:78;;;;72213:7;-1:-1:-1;;;;;72197:31:0;72206:5;-1:-1:-1;;;;;72197:31:0;;72222:5;72197:31;;;;597:25:1;;585:2;570:18;;451:177;72197:31:0;;;;;;;;71804:443;;;;:::o;70018:1640::-;-1:-1:-1;;;;;70137:15:0;;;70115:19;70137:15;;;:9;:15;;;;;;;70183:13;;;;;;;;70211:19;;;70207:109;;;70254:50;;-1:-1:-1;;;70254:50:0;;-1:-1:-1;;;;;21560:32:1;;70254:50:0;;;21542:51:1;21609:18;;;21602:34;;;21652:18;;;21645:34;;;21515:18;;70254:50:0;21340:345:1;70207:109:0;-1:-1:-1;;;;;70429:15:0;;;;;;;:9;:15;;;;;;70447:19;;;70429:37;;70597:13;;;;;;;;;;70613:17;;;70597:33;;70659:25;;-1:-1:-1;;;;;;;;;;;70659:25:0;;;70461:5;597:25:1;;585:2;570:18;;451:177;70659:25:0;;;;;;;;70700:4;70697:954;;;-1:-1:-1;;;;;70792:15:0;;70781:8;70792:15;;;:9;:15;;;;;;;;;70822:234;;70851:22;70932:12;70909:19;70923:5;70909:11;:19;:::i;:::-;70908:36;;;;:::i;:::-;70877:26;70891:12;70877:11;:26;:::i;:::-;70876:69;;;;:::i;:::-;70851:94;-1:-1:-1;70967:18:0;;70964:76;;71008:32;71019:4;71025:14;71008:10;:32::i;:::-;70832:224;70822:234;-1:-1:-1;;;;;71140:13:0;;;;;;:9;:13;;;;;;;;71135:505;;71177:10;;71191:1;71177:15;:22;;;;;71196:3;71177:22;:41;;;;-1:-1:-1;2000:7:0;2027:6;-1:-1:-1;;;;;71203:15:0;;;2027:6;;71203:15;71177:41;71174:451;;;-1:-1:-1;;;;;71301:13:0;;;;;;:9;:13;;;;;:20;;-1:-1:-1;;71301:20:0;71317:4;71301:20;;;71357:1;71344:10;:14;71174:451;;;71407:22;71472:24;71484:12;71472:9;:24;:::i;:::-;71455:12;71434:17;71446:5;71434:9;:17;:::i;:::-;71433:34;;;;:::i;:::-;71432:65;;;;:::i;:::-;71407:90;-1:-1:-1;71523:18:0;;71520:85;;71568:37;71586:2;71590:14;71568:17;:37::i;71520:85::-;71384:241;71174:451;70706:945;70697:954;70104:1554;;70018:1640;;;;:::o;67704:162::-;67813:16;;;67827:1;67813:16;;;;;;;;;67770:22;;67813:16;;;;;;;;;;;-1:-1:-1;67813:16:0;67805:24;;67851:7;67840:5;67846:1;67840:8;;;;;;;;:::i;:::-;;;;;;:18;;;;;67704:162;;;:::o;76274:677::-;-1:-1:-1;;;;;76445:13:0;;;;;;:9;:13;;;;;;;;76441:422;;76500:9;;-1:-1:-1;;;;;76483:13:0;;;;;;:9;:13;;;;;;:26;;76475:70;;;;-1:-1:-1;;;76475:70:0;;23029:2:1;76475:70:0;;;23011:21:1;23068:2;23048:18;;;23041:30;23107:33;23087:18;;;23080:61;23158:18;;76475:70:0;22827:355:1;76475:70:0;76564:13;;;;76560:292;;;76617:9;76606:21;;;;:10;:21;;;;;;76630:12;-1:-1:-1;76598:84:0;;;;-1:-1:-1;;;76598:84:0;;23389:2:1;76598:84:0;;;23371:21:1;23428:2;23408:18;;;23401:30;23467:34;23447:18;;;23440:62;-1:-1:-1;;;23518:18:1;;;23511:34;23562:19;;76598:84:0;23187:400:1;76598:84:0;76712:9;76701:21;;;;:10;:21;;;;;76725:12;76701:36;;-1:-1:-1;;;;;76766:23:0;;;:28;76758:78;;;;-1:-1:-1;;;76758:78:0;;23794:2:1;76758:78:0;;;23776:21:1;23833:2;23813:18;;;23806:30;23872:34;23852:18;;;23845:62;-1:-1:-1;;;23923:18:1;;;23916:35;23968:19;;76758:78:0;23592:401:1;76758:78:0;76893:50;69685:325;65502:1389;-1:-1:-1;;;;;65717:13:0;;5754:20;5802:8;65713:1171;;65753:57;;-1:-1:-1;;;65753:57:0;;-1:-1:-1;;;65753:57:0;;;24142:52:1;-1:-1:-1;;;;;65753:29:0;;;;;24115:18:1;;65753:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;65749:1124;;;65835:72;;-1:-1:-1;;;65835:72:0;;-1:-1:-1;;;;;65835:38:0;;;;;:72;;65874:8;;65884:4;;65890:2;;65894:6;;65902:4;;65835:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65835:72:0;;;;;;;;-1:-1:-1;;65835:72:0;;;;;;;;;;;;:::i;:::-;;;65831:495;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;66201:6;66194:14;;-1:-1:-1;;;66194:14:0;;;;;;;;:::i;65831:495::-;;;66265:41;;-1:-1:-1;;;66265:41:0;;;;;;;;;;;65831:495;-1:-1:-1;;;;;;65961:55:0;;-1:-1:-1;;;65961:55:0;65957:160;;66052:41;;-1:-1:-1;;;66052:41:0;;;;;;;;;;;65957:160;65908:228;65749:1124;;;66383:61;;-1:-1:-1;;;66383:61:0;;-1:-1:-1;;;;;66383:35:0;;;;;:61;;66419:8;;66429:4;;66435:2;;66439:4;;66383:61;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;66383:61:0;;;;;;;;-1:-1:-1;;66383:61:0;;;;;;;;;;;;:::i;:::-;;;66379:479;;;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;;;66798:40;;-1:-1:-1;;;66798:40:0;;;;;;;;;;;66379:479;-1:-1:-1;;;;;;66498:52:0;;-1:-1:-1;;;66498:52:0;66494:156;;66586:40;;-1:-1:-1;;;66586:40:0;;;;;;;;;;;27460:464;27824:12;27697:11;27690:1;27686:9;;;27682:27;27675:35;;27762:1;27758:9;;;27769:11;27754:27;;;27733:19;;27729:53;27816:1;27812:9;;;27805:17;27801:36;27890:13;27883:21;27878:3;27874:31;-1:-1:-1;;27646:10:0;;;;27863:1;27859:13;27856:50;;27460:464::o;66899:797::-;-1:-1:-1;;;;;67139:13:0;;5754:20;5802:8;67135:554;;67175:79;;-1:-1:-1;;;67175:79:0;;-1:-1:-1;;;;;67175:43:0;;;;;:79;;67219:8;;67229:4;;67235:3;;67240:7;;67249:4;;67175:79;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67175:79:0;;;;;;;;-1:-1:-1;;67175:79:0;;;;;;;;;;;;:::i;:::-;;;67171:507;;;;:::i;:::-;-1:-1:-1;;;;;;67336:60:0;;-1:-1:-1;;;67336:60:0;67332:157;;67428:41;;-1:-1:-1;;;67428:41:0;;;;;;;;;;;61005:1784;-1:-1:-1;;;;;61111:18:0;;61108:77;;61152:21;;-1:-1:-1;;;61152:21:0;;;;;;;;;;;61108:77;44251:13;;175:10;;61289:24;61330:6;-1:-1:-1;;;;;61316:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61316:21:0;;61289:48;;61348:20;61385:6;-1:-1:-1;;;;;61371:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;61371:21:0;;61348:44;;61434:9;61430:258;61453:6;61449:1;:10;61430:258;;;61498:1;61485:7;61493:1;61485:10;;;;;;;;:::i;:::-;;;;;;;;;;;:14;;;;-1:-1:-1;;;;;61531:12:0;;61518:10;61531:12;;;:6;:12;;;;;;:36;;61556:10;61531:24;:36::i;:::-;61518:49;;61595:2;61586:3;61590:1;61586:6;;;;;;;;:::i;:::-;;;;;;;;;;;:11;;;;-1:-1:-1;;;;;61616:12:0;;;;;;:6;:12;;;;;;;34204:1;34195:10;;;34184:22;;;;;;;;:48;;34226:4;34218:12;;34212:19;;;34210:22;34184:48;;;34195:10;;-1:-1:-1;61461:3:0;61430:258;;;;61839:18;;61882:10;:6;61891:1;61882:10;:::i;:::-;61868:24;;-1:-1:-1;;;;;61947:4:0;61943:27;61929:41;;62155:4;62150:3;62146:14;62140:21;62120:1;62091:10;-1:-1:-1;;;;;;;;;;;62027:1:0;62007;61984:192;62230:1;62192:264;62266:3;62257:7;62254:16;62192:264;;62430:7;62424:4;62420:18;62415:3;62411:28;62405:35;62402:1;62390:10;-1:-1:-1;;;;;;;;;;;62360:1:0;62357;62352:89;62315:1;62302:15;62192:264;;;-1:-1:-1;62727:52:0;62747:8;62757:4;62771:1;62775:3;62727:19;:52::i;56194:1695::-;56299:20;;-1:-1:-1;;;;;56363:16:0;;56360:74;;56403:19;;-1:-1:-1;;;56403:19:0;;;;;;;;;;;56360:74;56447:6;56457:1;56447:11;56444:68;;56482:18;;-1:-1:-1;;;56482:18:0;;;;;;;;;;;56444:68;175:10;56588:6;-1:-1:-1;;;;;56574:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56574:21:0;;56568:27;;56630:6;-1:-1:-1;;;;;56616:21:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56616:21:0;;56606:31;;56648:20;56671:14;44251:13;;;44177:95;56671:14;56648:37;;56761:12;56751:6;-1:-1:-1;;56731:26:0;:42;;56723:51;;;;;;56793:9;56789:129;56812:6;56808:1;:10;56789:129;;;56868:1;56853:12;:16;56844:3;56848:1;56844:6;;;;;;;;:::i;:::-;;;;;;:25;;;;;56901:1;56888:7;56896:1;56888:10;;;;;;;;:::i;:::-;;;;;;;;;;:14;56820:3;;56789:129;;;;-1:-1:-1;;;;;57013:10:0;;;;;;:6;:10;;;;;:41;;57033:12;57047:6;57013:19;:41::i;:::-;57082:6;57065:13;;:23;;;;;;;:::i;:::-;;;;-1:-1:-1;57101:16:0;;-1:-1:-1;57101:16:0;57142:21;57157:6;57142:12;:21;:::i;:::-;57128:35;;-1:-1:-1;;;;;57216:2:0;57212:25;57200:37;;57405:12;57378:8;57358:1;-1:-1:-1;;;;;;;;;;;57294:1:0;57274;57251:181;57504:1;57490:12;57486:20;57448:253;57541:3;57532:7;57529:16;57448:253;;57678:7;57668:8;57665:1;-1:-1:-1;;;;;;;;;;;57635:1:0;57632;57627:59;57590:1;57577:15;57448:253;;;-1:-1:-1;57829:50:0;57849:8;57867:1;57871:2;57875:3;57829:19;:50::i;:::-;56347:1542;;;;56194:1695;;;;;:::o;39395:1230::-;39713:1;39709:14;;;39505:19;39737:20;;;39778:4;39771:25;;;39951:4;39935:21;;39929:28;-1:-1:-1;;39679:6:0;39709:14;39828:4;39834:11;;39824:22;39917:41;;;39905:54;;39998:14;;39983:30;;39973:356;;40034:280;-1:-1:-1;40079:24:0;;40153:4;40146:20;;;40224:4;40208:21;;40202:28;40270:14;;40255:30;;40252:43;40034:280;40252:43;40034:280;40354:15;;40350:268;;40416:22;40427:10;25416:66;25340:4;25361:34;24966:9;;24963:1;24959:17;24988:34;24985:41;-1:-1:-1;24982:1:0;24978:49;24956:72;25083:9;;;-1:-1:-1;;;;;25060:33:0;25057:1;25053:41;25047:48;25142:9;;;25130:10;25127:25;25124:1;25120:33;25114:40;25197:9;;;25189:6;25186:21;25183:1;25179:29;25173:36;25250:9;;;25244:4;25241:19;25238:1;25234:27;25228:34;25350:9;;;25346:50;25336:61;25331:152;25325:159;;24814:688;40416:22;40411:1;40401:11;;;40400:38;40567:23;;;40564:1;40560:31;40544:48;;-1:-1:-1;40350:268:0;39531:1094;;39395:1230;;;;:::o;35948:1129::-;36123:1;36119:6;36163:4;36156:5;36152:16;36195:11;36189:4;36182:25;36241:5;36238:1;36234:13;36228:4;36221:27;36295:3;36286:6;36279:5;36275:18;36272:27;36262:646;;36349:4;36339:21;;36355:4;36339:21;;36401:18;;36421:15;;;36398:39;36378:60;;36548:18;;;;36620:4;36596:29;;;-1:-1:-1;36470:19:0;;;36545:1;36541:26;36524:44;36671:184;36696:9;36688:6;36685:21;36671:184;;36773:6;36767:4;36760:20;36832:3;36825:4;36819;36809:21;36802:34;36732:1;36724:6;36720:14;36710:24;;36671:184;;;-1:-1:-1;36880:4:0;36873:20;36262:646;36957:4;36951;36941:21;37052:3;37043:6;37038:3;37034:16;37030:26;37023:5;37019:38;37005:11;36999:18;36996:62;36983:11;36976:83;;;;35948:1129;;;:::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:282::-;2835:3;2873:5;2867:12;2900:6;2895:3;2888:19;2916:76;2985:6;2978:4;2973:3;2969:14;2962:4;2955:5;2951:16;2916:76;:::i;:::-;3046:2;3025:15;-1:-1:-1;;3021:29:1;3012:39;;;;3053:4;3008:50;;2782:282;-1:-1:-1;;2782:282:1:o;3069:231::-;3218:2;3207:9;3200:21;3181:4;3238:56;3290:2;3279:9;3275:18;3267:6;3238:56;:::i;3305:180::-;3364:6;3417:2;3405:9;3396:7;3392:23;3388:32;3385:52;;;3433:1;3430;3423:12;3385:52;-1:-1:-1;3456:23:1;;3305:180;-1:-1:-1;3305:180:1:o;3698:328::-;3775:6;3783;3791;3844:2;3832:9;3823:7;3819:23;3815:32;3812:52;;;3860:1;3857;3850:12;3812:52;3883:29;3902:9;3883:29;:::i;:::-;3873:39;;3931:38;3965:2;3954:9;3950:18;3931:38;:::i;:::-;3921:48;;4016:2;4005:9;4001:18;3988:32;3978:42;;3698:328;;;;;:::o;4031:322::-;4108:6;4116;4124;4177:2;4165:9;4156:7;4152:23;4148:32;4145:52;;;4193:1;4190;4183:12;4145:52;4216:29;4235:9;4216:29;:::i;:::-;4206:39;4292:2;4277:18;;4264:32;;-1:-1:-1;4343:2:1;4328:18;;;4315:32;;4031:322;-1:-1:-1;;;4031:322:1:o;4358:183::-;4418:4;-1:-1:-1;;;;;4443:6:1;4440:30;4437:56;;;4473:18;;:::i;:::-;-1:-1:-1;4518:1:1;4514:14;4530:4;4510:25;;4358:183::o;4546:730::-;4600:5;4653:3;4646:4;4638:6;4634:17;4630:27;4620:55;;4671:1;4668;4661:12;4620:55;4707:6;4694:20;4733:4;4756:43;4796:2;4756:43;:::i;:::-;4828:2;4822:9;4840:31;4868:2;4860:6;4840:31;:::i;:::-;4891:6;4880:17;;4921:2;4913:6;4906:18;4952:4;4944:6;4940:17;4933:24;;5009:4;5003:2;5000:1;4996:10;4988:6;4984:23;4980:34;4966:48;;5037:3;5029:6;5026:15;5023:35;;;5054:1;5051;5044:12;5023:35;5090:4;5082:6;5078:17;5104:142;5120:6;5115:3;5112:15;5104:142;;;5186:17;;5174:30;;5224:12;;;;5137;;5104:142;;;-1:-1:-1;5264:6:1;4546:730;-1:-1:-1;;;;;;4546:730:1:o;5281:221::-;5323:5;5376:3;5369:4;5361:6;5357:17;5353:27;5343:55;;5394:1;5391;5384:12;5343:55;5416:80;5492:3;5483:6;5470:20;5463:4;5455:6;5451:17;5416:80;:::i;5507:943::-;5661:6;5669;5677;5685;5693;5746:3;5734:9;5725:7;5721:23;5717:33;5714:53;;;5763:1;5760;5753:12;5714:53;5786:29;5805:9;5786:29;:::i;:::-;5776:39;;5834:38;5868:2;5857:9;5853:18;5834:38;:::i;:::-;5824:48;;5923:2;5912:9;5908:18;5895:32;-1:-1:-1;;;;;5987:2:1;5979:6;5976:14;5973:34;;;6003:1;6000;5993:12;5973:34;6026:61;6079:7;6070:6;6059:9;6055:22;6026:61;:::i;:::-;6016:71;;6140:2;6129:9;6125:18;6112:32;6096:48;;6169:2;6159:8;6156:16;6153:36;;;6185:1;6182;6175:12;6153:36;6208:63;6263:7;6252:8;6241:9;6237:24;6208:63;:::i;:::-;6198:73;;6324:3;6313:9;6309:19;6296:33;6280:49;;6354:2;6344:8;6341:16;6338:36;;;6370:1;6367;6360:12;6338:36;;6393:51;6436:7;6425:8;6414:9;6410:24;6393:51;:::i;:::-;6383:61;;;5507:943;;;;;;;;:::o;6644:1208::-;6762:6;6770;6823:2;6811:9;6802:7;6798:23;6794:32;6791:52;;;6839:1;6836;6829:12;6791:52;6879:9;6866:23;-1:-1:-1;;;;;6949:2:1;6941:6;6938:14;6935:34;;;6965:1;6962;6955:12;6935:34;7003:6;6992:9;6988:22;6978:32;;7048:7;7041:4;7037:2;7033:13;7029:27;7019:55;;7070:1;7067;7060:12;7019:55;7106:2;7093:16;7128:4;7151:43;7191:2;7151:43;:::i;:::-;7223:2;7217:9;7235:31;7263:2;7255:6;7235:31;:::i;:::-;7301:18;;;7389:1;7385:10;;;;7377:19;;7373:28;;;7335:15;;;;-1:-1:-1;7413:19:1;;;7410:39;;;7445:1;7442;7435:12;7410:39;7469:11;;;;7489:148;7505:6;7500:3;7497:15;7489:148;;;7571:23;7590:3;7571:23;:::i;:::-;7559:36;;7522:12;;;;7615;;;;7489:148;;;7656:6;-1:-1:-1;;7700:18:1;;7687:32;;-1:-1:-1;;7731:16:1;;;7728:36;;;7760:1;7757;7750:12;7728:36;;7783:63;7838:7;7827:8;7816:9;7812:24;7783:63;:::i;:::-;7773:73;;;6644:1208;;;;;:::o;7857:439::-;7910:3;7948:5;7942:12;7975:6;7970:3;7963:19;8001:4;8030;8025:3;8021:14;8014:21;;8069:4;8062:5;8058:16;8092:1;8102:169;8116:6;8113:1;8110:13;8102:169;;;8177:13;;8165:26;;8211:12;;;;8246:15;;;;8138:1;8131:9;8102:169;;;-1:-1:-1;8287:3:1;;7857:439;-1:-1:-1;;;;;7857:439:1:o;8301:261::-;8480:2;8469:9;8462:21;8443:4;8500:56;8552:2;8541:9;8537:18;8529:6;8500:56;:::i;8567:118::-;8653:5;8646:13;8639:21;8632:5;8629:32;8619:60;;8675:1;8672;8665:12;8690:315;8755:6;8763;8816:2;8804:9;8795:7;8791:23;8787:32;8784:52;;;8832:1;8829;8822:12;8784:52;8855:29;8874:9;8855:29;:::i;:::-;8845:39;;8934:2;8923:9;8919:18;8906:32;8947:28;8969:5;8947:28;:::i;:::-;8994:5;8984:15;;;8690:315;;;;;:::o;9010:186::-;9069:6;9122:2;9110:9;9101:7;9097:23;9093:32;9090:52;;;9138:1;9135;9128:12;9090:52;9161:29;9180:9;9161:29;:::i;9383:260::-;9451:6;9459;9512:2;9500:9;9491:7;9487:23;9483:32;9480:52;;;9528:1;9525;9518:12;9480:52;9551:29;9570:9;9551:29;:::i;:::-;9541:39;;9599:38;9633:2;9622:9;9618:18;9599:38;:::i;:::-;9589:48;;9383:260;;;;;:::o;9648:606::-;9752:6;9760;9768;9776;9784;9837:3;9825:9;9816:7;9812:23;9808:33;9805:53;;;9854:1;9851;9844:12;9805:53;9877:29;9896:9;9877:29;:::i;:::-;9867:39;;9925:38;9959:2;9948:9;9944:18;9925:38;:::i;:::-;9915:48;;10010:2;9999:9;9995:18;9982:32;9972:42;;10061:2;10050:9;10046:18;10033:32;10023:42;;10116:3;10105:9;10101:19;10088:33;-1:-1:-1;;;;;10136:6:1;10133:30;10130:50;;;10176:1;10173;10166:12;10130:50;10199:49;10240:7;10231:6;10220:9;10216:22;10199:49;:::i;10259:380::-;10338:1;10334:12;;;;10381;;;10402:61;;10456:4;10448:6;10444:17;10434:27;;10402:61;10509:2;10501:6;10498:14;10478:18;10475:38;10472:161;;10555:10;10550:3;10546:20;10543:1;10536:31;10590:4;10587:1;10580:15;10618:4;10615:1;10608:15;10472:161;;10259:380;;;:::o;10981:127::-;11042:10;11037:3;11033:20;11030:1;11023:31;11073:4;11070:1;11063:15;11097:4;11094:1;11087:15;11113:128;11180:9;;;11201:11;;;11198:37;;;11215:18;;:::i;11689:518::-;11791:2;11786:3;11783:11;11780:421;;;11827:5;11824:1;11817:16;11871:4;11868:1;11858:18;11941:2;11929:10;11925:19;11922:1;11918:27;11912:4;11908:38;11977:4;11965:10;11962:20;11959:47;;;-1:-1:-1;12000:4:1;11959:47;12055:2;12050:3;12046:12;12043:1;12039:20;12033:4;12029:31;12019:41;;12110:81;12128:2;12121:5;12118:13;12110:81;;;12187:1;12173:16;;12154:1;12143:13;12110:81;;12383:1345;12509:3;12503:10;-1:-1:-1;;;;;12528:6:1;12525:30;12522:56;;;12558:18;;:::i;:::-;12587:97;12677:6;12637:38;12669:4;12663:11;12637:38;:::i;:::-;12631:4;12587:97;:::i;:::-;12739:4;;12796:2;12785:14;;12813:1;12808:663;;;;13515:1;13532:6;13529:89;;;-1:-1:-1;13584:19:1;;;13578:26;13529:89;-1:-1:-1;;12340:1:1;12336:11;;;12332:24;12328:29;12318:40;12364:1;12360:11;;;12315:57;13631:81;;12778:944;;12808:663;11636:1;11629:14;;;11673:4;11660:18;;-1:-1:-1;;12844:20:1;;;12962:236;12976:7;12973:1;12970:14;12962:236;;;13065:19;;;13059:26;13044:42;;13157:27;;;;13125:1;13113:14;;;;12992:19;;12962:236;;;12966:3;13226:6;13217:7;13214:19;13211:201;;;13287:19;;;13281:26;-1:-1:-1;;13370:1:1;13366:14;;;13382:3;13362:24;13358:37;13354:42;13339:58;13324:74;;13211:201;-1:-1:-1;;;;;13458:1:1;13442:14;;;13438:22;13425:36;;-1:-1:-1;12383:1345:1:o;13733:127::-;13794:10;13789:3;13785:20;13782:1;13775:31;13825:4;13822:1;13815:15;13849:4;13846:1;13839:15;13865:168;13938:9;;;13969;;13986:15;;;13980:22;;13966:37;13956:71;;14007:18;;:::i;14038:127::-;14099:10;14094:3;14090:20;14087:1;14080:31;14130:4;14127:1;14120:15;14154:4;14151:1;14144:15;14170:120;14210:1;14236;14226:35;;14241:18;;:::i;:::-;-1:-1:-1;14275:9:1;;14170:120::o;14295:340::-;14497:2;14479:21;;;14536:2;14516:18;;;14509:30;-1:-1:-1;;;14570:2:1;14555:18;;14548:46;14626:2;14611:18;;14295:340::o;14640:125::-;14705:9;;;14726:10;;;14723:36;;;14739:18;;:::i;15837:198::-;15879:3;15917:5;15911:12;15932:65;15990:6;15985:3;15978:4;15971:5;15967:16;15932:65;:::i;:::-;16013:16;;;;;15837:198;-1:-1:-1;;15837:198:1:o;16040:1021::-;16216:3;16245:1;16278:6;16272:13;16308:36;16334:9;16308:36;:::i;:::-;16363:1;16380:17;;;16406:133;;;;16553:1;16548:358;;;;16373:533;;16406:133;-1:-1:-1;;16439:24:1;;16427:37;;16512:14;;16505:22;16493:35;;16484:45;;;-1:-1:-1;16406:133:1;;16548:358;16579:6;16576:1;16569:17;16609:4;16654;16651:1;16641:18;16681:1;16695:165;16709:6;16706:1;16703:13;16695:165;;;16787:14;;16774:11;;;16767:35;16830:16;;;;16724:10;;16695:165;;;16699:3;;;16889:6;16884:3;16880:16;16873:23;;16373:533;;;;;16937:6;16931:13;16953:68;17012:8;17007:3;17000:4;16992:6;16988:17;16953:68;:::i;:::-;17037:18;;16040:1021;-1:-1:-1;;;;16040:1021:1:o;17810:2160::-;-1:-1:-1;;;18853:45:1;;18921:13;;18835:3;;18943:75;18921:13;19006:2;18997:12;;18990:4;18978:17;;18943:75;:::i;:::-;-1:-1:-1;;;19077:2:1;19037:16;;;19069:11;;;19062:30;19117:13;;19139:76;19117:13;19201:2;19193:11;;19186:4;19174:17;;19139:76;:::i;:::-;-1:-1:-1;;;19275:2:1;19234:17;;;;19267:11;;;19260:67;19352:13;;19374:76;19352:13;19436:2;19428:11;;19421:4;19409:17;;19374:76;:::i;:::-;19515:66;19510:2;19469:17;;;;19502:11;;;19495:87;-1:-1:-1;;;19606:2:1;19598:11;;19591:65;19681:13;;19703:76;19681:13;19765:2;19757:11;;19750:4;19738:17;;19703:76;:::i;:::-;19795:169;19825:138;19851:111;19877:84;19907:53;19956:2;19945:8;19941:2;19937:17;19933:26;19925:6;19907:53;:::i;:::-;17582:66;17570:79;;17674:2;17665:12;;17505:178;19877:84;19869:6;19851:111;:::i;:::-;19843:6;19825:138;:::i;:::-;-1:-1:-1;;;17753:19:1;;17797:1;17788:11;;17688:117;19795:169;19788:176;17810:2160;-1:-1:-1;;;;;;;;;;;17810:2160:1:o;19975:1107::-;20487:29;20482:3;20475:42;20457:3;20546:6;20540:13;20562:75;20630:6;20625:2;20620:3;20616:12;20609:4;20601:6;20597:17;20562:75;:::i;:::-;20701:66;20696:2;20656:16;;;20688:11;;;20681:87;-1:-1:-1;;;20792:2:1;20784:11;;20777:63;20865:13;;20887:76;20865:13;20949:2;20941:11;;20934:4;20922:17;;20887:76;:::i;:::-;-1:-1:-1;;;21023:2:1;20982:17;;;;21015:11;;;21008:41;21073:2;21065:11;;19975:1107;-1:-1:-1;;;;19975:1107:1:o;22570:135::-;22609:3;22630:17;;;22627:43;;22650:18;;:::i;:::-;-1:-1:-1;22697:1:1;22686:13;;22570:135::o;22710:112::-;22742:1;22768;22758:35;;22773:18;;:::i;:::-;-1:-1:-1;22807:9:1;;22710:112::o;24205:245::-;24272:6;24325:2;24313:9;24304:7;24300:23;24296:32;24293:52;;;24341:1;24338;24331:12;24293:52;24373:9;24367:16;24392:28;24414:5;24392:28;:::i;24455:572::-;-1:-1:-1;;;;;24752:15:1;;;24734:34;;24804:15;;24799:2;24784:18;;24777:43;24851:2;24836:18;;24829:34;;;24894:2;24879:18;;24872:34;;;24714:3;24937;24922:19;;24915:32;;;24677:4;;24964:57;;25001:19;;24993:6;24964:57;:::i;:::-;24956:65;24455:572;-1:-1:-1;;;;;;;24455:572:1:o;25032:249::-;25101:6;25154:2;25142:9;25133:7;25129:23;25125:32;25122:52;;;25170:1;25167;25160:12;25122:52;25202:9;25196:16;25221:30;25245:5;25221:30;:::i;25286:179::-;25321:3;25363:1;25345:16;25342:23;25339:120;;;25409:1;25406;25403;25388:23;-1:-1:-1;25446:1:1;25440:8;25435:3;25431:18;25339:120;25286:179;:::o;25470:671::-;25509:3;25551:4;25533:16;25530:26;25527:39;;;25470:671;:::o;25527:39::-;25593:2;25587:9;-1:-1:-1;;25658:16:1;25654:25;;25651:1;25587:9;25630:50;25709:4;25703:11;25733:16;-1:-1:-1;;;;;25839:2:1;25832:4;25824:6;25820:17;25817:25;25812:2;25804:6;25801:14;25798:45;25795:58;;;25846:5;;;;;25470:671;:::o;25795:58::-;25883:6;25877:4;25873:17;25862:28;;25919:3;25913:10;25946:2;25938:6;25935:14;25932:27;;;25952:5;;;;;;25470:671;:::o;25932:27::-;26036:2;26017:16;26011:4;26007:27;26003:36;25996:4;25987:6;25982:3;25978:16;25974:27;25971:69;25968:82;;;26043:5;;;;;;25470:671;:::o;25968:82::-;26059:57;26110:4;26101:6;26093;26089:19;26085:30;26079:4;26059:57;:::i;:::-;-1:-1:-1;26132:3:1;;25470:671;-1:-1:-1;;;;;25470:671:1:o;26146:500::-;-1:-1:-1;;;;;26415:15:1;;;26397:34;;26467:15;;26462:2;26447:18;;26440:43;26514:2;26499:18;;26492:34;;;26562:3;26557:2;26542:18;;26535:31;;;26340:4;;26583:57;;26620:19;;26612:6;26583:57;:::i;:::-;26575:65;26146:500;-1:-1:-1;;;;;;26146:500:1:o;26651:838::-;-1:-1:-1;;;;;27048:15:1;;;27030:34;;27100:15;;27095:2;27080:18;;27073:43;27010:3;27147:2;27132:18;;27125:31;;;26973:4;;27179:57;;27216:19;;27208:6;27179:57;:::i;:::-;27284:9;27276:6;27272:22;27267:2;27256:9;27252:18;27245:50;27318:44;27355:6;27347;27318:44;:::i;:::-;27304:58;;27411:9;27403:6;27399:22;27393:3;27382:9;27378:19;27371:51;27439:44;27476:6;27468;27439:44;:::i;:::-;27431:52;26651:838;-1:-1:-1;;;;;;;;26651:838:1:o

Swarm Source

ipfs://5f332f765df708f90e640e9194c486ea5131e9276cf4049853a5487f90f13670

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