Token

Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// Not your average 404.
// - Telegram :  https://t.me/Olympus404Portal
// - Website  :  https://olympus404.xyz/
// - Twitter  :  https://twitter.com/Olympus_404
// 
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀  ⠀⠀⠀⠀⣀⣤⣶⣿⣿⣶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀ ⣀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣤⣀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⢀⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⡀⠀⠀⠀
// ⠀⠀⠀⠀⢤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⡤⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣤⣤⠀⠀⠀⠀⢠⣤⠀⠀⠀⠀⣤⡄⠀⠀⠀⠀⣤⣤⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⠛⠛⠀⠀⠀⠀⠘⠛⠀⠀⠀⠀⠛⠃⠀⠀⠀⠀⠛⠛⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀
// ⠀⠀⢰⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⡆⠀⠀
// ⠀⠀⠈⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "./DN404.sol";
import {DailyOutflowCounterLib} from "./DailyOutflowCounterLib.sol";
import {OwnableRoles} from "./OwnableRoles.sol";
import {LibString} from "./LibString.sol";
import {GasBurnerLib} from "./GasBurnerLib.sol";

contract Olympus is DN404, OwnableRoles {
    using DailyOutflowCounterLib for *;

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                         CONSTANTS                          */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    uint256 public constant ADMIN_ROLE = _ROLE_0;

    error MaxBalanceLimitReached();

    string internal _baseURI;

    constructor()
    {
        _construct(tx.origin);
    }

    function _construct(address initialOwner) internal {
        _initializeOwner(initialOwner);
        _setWhitelisted(initialOwner, true);
        _baseURI = "https://raw.githubusercontent.com/OlympusERC404/Olympus404/main/{id}.png";
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                          METADATA                          */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    function name() public pure override returns (string memory) {
        return "Olympus";
    }

    function symbol() public pure override returns (string memory) {
        return "OLYMP";
    }

    function tokenURI(uint256 id) public view override returns (string memory result) {
        string memory jsonPreImage = string.concat(
            string.concat(
                string.concat('{"name": "OLYMP #', LibString.toString(id)),
                '","description":"A collection of 3333 Replicants enabled by ERC404, an experimental token standard.","external_url":"https://olympus404.xyz/","image":"'
            ),
            LibString.replace(_baseURI, "{id}", LibString.toString(tokenId[id]))
        );
        string memory jsonPostTraits = '"}';
        return
            string.concat(
                "data:application/json;utf8,",
                string.concat(
                    jsonPreImage,
                    jsonPostTraits
                )
            );
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                         TRANSFERS                          */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    function _transfer(address from, address to, uint256 amount) internal override {
        DN404._transfer(from, to, amount);
    }

    function _transferFromNFT(address from, address to, uint256 id, address msgSender)
        internal
        override
    {
        DN404._transferFromNFT(from, to, id, msgSender);
    }

    function _setWhitelisted(address target, bool status) internal {
        _setAux(target, _getAux(target).setWhitelisted(status));
    }

    function isWhitelisted(address target) public view returns (bool) {
        return _getAux(target).isWhitelisted();
    }

    function initialize(address mirror) public onlyOwnerOrRoles(ADMIN_ROLE) {
        uint256 initialTokenSupply = 3333 * _WAD;
        address initialSupplyOwner = msg.sender;
        _initializeDN404(initialTokenSupply, initialSupplyOwner, mirror);
        _setWhitelisted(initialSupplyOwner, true);
    }

    function setWhitelist(address target, bool status) public onlyOwnerOrRoles(ADMIN_ROLE) {
        _setWhitelisted(target, status);
    }

    function setVrfId(uint64 vrfid) public onlyOwnerOrRoles(ADMIN_ROLE) {
        _setVrfId(vrfid);
    }

    function setKeyHash(bytes32 keyHash) public onlyOwnerOrRoles(ADMIN_ROLE) {
        _setKeyHash(keyHash);
    }

    function setMaxWallet(bool status) public onlyOwnerOrRoles(ADMIN_ROLE) {
        _setMaxWallet(status);
    }

    function setLPAddress(address lp) public onlyOwnerOrRoles(ADMIN_ROLE) {
        _setLPAddress(lp);
    }

    function setCanReveal(bool can) public onlyOwnerOrRoles(ADMIN_ROLE) {
        _setCanReveal(can);
    }

    function setLotteryHermesPrice(uint256 value) public onlyOwnerOrRoles(ADMIN_ROLE) {
        _setLotteryHermesPrice(value);
    }

    function setLotteryPrice(uint256 value) public onlyOwnerOrRoles(ADMIN_ROLE) {
        _setLotteryPrice(value);
    }
}

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

interface VRFCoordinatorV2Interface {
  /**
   * @notice Get configuration relevant for making requests
   * @return minimumRequestConfirmations global min for request confirmations
   * @return maxGasLimit global max for request gas limit
   * @return s_provingKeyHashes list of registered key hashes
   */
  function getRequestConfig() external view returns (uint16, uint32, bytes32[] memory);

  /**
   * @notice Request a set of random words.
   * @param keyHash - Corresponds to a particular oracle job which uses
   * that key for generating the VRF proof. Different keyHash's have different gas price
   * ceilings, so you can select a specific one to bound your maximum per request cost.
   * @param subId  - The ID of the VRF subscription. Must be funded
   * with the minimum subscription balance required for the selected keyHash.
   * @param minimumRequestConfirmations - How many blocks you'd like the
   * oracle to wait before responding to the request. See SECURITY CONSIDERATIONS
   * for why you may want to request more. The acceptable range is
   * [minimumRequestBlockConfirmations, 200].
   * @param callbackGasLimit - How much gas you'd like to receive in your
   * fulfillRandomWords callback. Note that gasleft() inside fulfillRandomWords
   * may be slightly less than this amount because of gas used calling the function
   * (argument decoding etc.), so you may need to request slightly more than you expect
   * to have inside fulfillRandomWords. The acceptable range is
   * [0, maxGasLimit]
   * @param numWords - The number of uint256 random values you'd like to receive
   * in your fulfillRandomWords callback. Note these numbers are expanded in a
   * secure way by the VRFCoordinator from a single random value supplied by the oracle.
   * @return requestId - A unique identifier of the request. Can be used to match
   * a request to a response in fulfillRandomWords.
   */
  function requestRandomWords(
    bytes32 keyHash,
    uint64 subId,
    uint16 minimumRequestConfirmations,
    uint32 callbackGasLimit,
    uint32 numWords
  ) external returns (uint256 requestId);

  /**
   * @notice Create a VRF subscription.
   * @return subId - A unique subscription id.
   * @dev You can manage the consumer set dynamically with addConsumer/removeConsumer.
   * @dev Note to fund the subscription, use transferAndCall. For example
   * @dev  LINKTOKEN.transferAndCall(
   * @dev    address(COORDINATOR),
   * @dev    amount,
   * @dev    abi.encode(subId));
   */
  function createSubscription() external returns (uint64 subId);

  /**
   * @notice Get a VRF subscription.
   * @param subId - ID of the subscription
   * @return balance - LINK balance of the subscription in juels.
   * @return reqCount - number of requests for this subscription, determines fee tier.
   * @return owner - owner of the subscription.
   * @return consumers - list of consumer address which are able to use this subscription.
   */
  function getSubscription(
    uint64 subId
  ) external view returns (uint96 balance, uint64 reqCount, address owner, address[] memory consumers);

  /**
   * @notice Request subscription owner transfer.
   * @param subId - ID of the subscription
   * @param newOwner - proposed new owner of the subscription
   */
  function requestSubscriptionOwnerTransfer(uint64 subId, address newOwner) external;

  /**
   * @notice Request subscription owner transfer.
   * @param subId - ID of the subscription
   * @dev will revert if original owner of subId has
   * not requested that msg.sender become the new owner.
   */
  function acceptSubscriptionOwnerTransfer(uint64 subId) external;

  /**
   * @notice Add a consumer to a VRF subscription.
   * @param subId - ID of the subscription
   * @param consumer - New consumer which can use the subscription
   */
  function addConsumer(uint64 subId, address consumer) external;

  /**
   * @notice Remove a consumer from a VRF subscription.
   * @param subId - ID of the subscription
   * @param consumer - Consumer to remove from the subscription
   */
  function removeConsumer(uint64 subId, address consumer) external;

  /**
   * @notice Cancel a subscription
   * @param subId - ID of the subscription
   * @param to - Where to send the remaining LINK to
   */
  function cancelSubscription(uint64 subId, address to) external;

  /*
   * @notice Check to see if there exists a request commitment consumers
   * for all consumers and keyhashes for a given sub.
   * @param subId - ID of the subscription
   * @return true if there exists at least one unfulfilled request for the subscription, false
   * otherwise.
   */
  function pendingRequestExists(uint64 subId) external view returns (bool);
}

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

/** ****************************************************************************
 * @notice Interface for contracts using VRF randomness
 * *****************************************************************************
 * @dev PURPOSE
 *
 * @dev Reggie the Random Oracle (not his real job) wants to provide randomness
 * @dev to Vera the verifier in such a way that Vera can be sure he's not
 * @dev making his output up to suit himself. Reggie provides Vera a public key
 * @dev to which he knows the secret key. Each time Vera provides a seed to
 * @dev Reggie, he gives back a value which is computed completely
 * @dev deterministically from the seed and the secret key.
 *
 * @dev Reggie provides a proof by which Vera can verify that the output was
 * @dev correctly computed once Reggie tells it to her, but without that proof,
 * @dev the output is indistinguishable to her from a uniform random sample
 * @dev from the output space.
 *
 * @dev The purpose of this contract is to make it easy for unrelated contracts
 * @dev to talk to Vera the verifier about the work Reggie is doing, to provide
 * @dev simple access to a verifiable source of randomness. It ensures 2 things:
 * @dev 1. The fulfillment came from the VRFCoordinator
 * @dev 2. The consumer contract implements fulfillRandomWords.
 * *****************************************************************************
 * @dev USAGE
 *
 * @dev Calling contracts must inherit from VRFConsumerBase, and can
 * @dev initialize VRFConsumerBase's attributes in their constructor as
 * @dev shown:
 *
 * @dev   contract VRFConsumer {
 * @dev     constructor(<other arguments>, address _vrfCoordinator, address _link)
 * @dev       VRFConsumerBase(_vrfCoordinator) public {
 * @dev         <initialization with other arguments goes here>
 * @dev       }
 * @dev   }
 *
 * @dev The oracle will have given you an ID for the VRF keypair they have
 * @dev committed to (let's call it keyHash). Create subscription, fund it
 * @dev and your consumer contract as a consumer of it (see VRFCoordinatorInterface
 * @dev subscription management functions).
 * @dev Call requestRandomWords(keyHash, subId, minimumRequestConfirmations,
 * @dev callbackGasLimit, numWords),
 * @dev see (VRFCoordinatorInterface for a description of the arguments).
 *
 * @dev Once the VRFCoordinator has received and validated the oracle's response
 * @dev to your request, it will call your contract's fulfillRandomWords method.
 *
 * @dev The randomness argument to fulfillRandomWords is a set of random words
 * @dev generated from your requestId and the blockHash of the request.
 *
 * @dev If your contract could have concurrent requests open, you can use the
 * @dev requestId returned from requestRandomWords to track which response is associated
 * @dev with which randomness request.
 * @dev See "SECURITY CONSIDERATIONS" for principles to keep in mind,
 * @dev if your contract could have multiple requests in flight simultaneously.
 *
 * @dev Colliding `requestId`s are cryptographically impossible as long as seeds
 * @dev differ.
 *
 * *****************************************************************************
 * @dev SECURITY CONSIDERATIONS
 *
 * @dev A method with the ability to call your fulfillRandomness method directly
 * @dev could spoof a VRF response with any random value, so it's critical that
 * @dev it cannot be directly called by anything other than this base contract
 * @dev (specifically, by the VRFConsumerBase.rawFulfillRandomness method).
 *
 * @dev For your users to trust that your contract's random behavior is free
 * @dev from malicious interference, it's best if you can write it so that all
 * @dev behaviors implied by a VRF response are executed *during* your
 * @dev fulfillRandomness method. If your contract must store the response (or
 * @dev anything derived from it) and use it later, you must ensure that any
 * @dev user-significant behavior which depends on that stored value cannot be
 * @dev manipulated by a subsequent VRF request.
 *
 * @dev Similarly, both miners and the VRF oracle itself have some influence
 * @dev over the order in which VRF responses appear on the blockchain, so if
 * @dev your contract could have multiple VRF requests in flight simultaneously,
 * @dev you must ensure that the order in which the VRF responses arrive cannot
 * @dev be used to manipulate your contract's user-significant behavior.
 *
 * @dev Since the block hash of the block which contains the requestRandomness
 * @dev call is mixed into the input to the VRF *last*, a sufficiently powerful
 * @dev miner could, in principle, fork the blockchain to evict the block
 * @dev containing the request, forcing the request to be included in a
 * @dev different block with a different hash, and therefore a different input
 * @dev to the VRF. However, such an attack would incur a substantial economic
 * @dev cost. This cost scales with the number of blocks the VRF oracle waits
 * @dev until it calls responds to a request. It is for this reason that
 * @dev that you can signal to an oracle you'd like them to wait longer before
 * @dev responding to the request (however this is not enforced in the contract
 * @dev and so remains effective only in the case of unmodified oracle software).
 */
abstract contract VRFConsumerBaseV2 {
  error OnlyCoordinatorCanFulfill(address have, address want);
  address private immutable vrfCoordinator;

  /**
   * @param _vrfCoordinator address of VRFCoordinator contract
   */
  constructor(address _vrfCoordinator) {
    vrfCoordinator = _vrfCoordinator;
  }

  /**
   * @notice fulfillRandomness handles the VRF response. Your contract must
   * @notice implement it. See "SECURITY CONSIDERATIONS" above for important
   * @notice principles to keep in mind when implementing your fulfillRandomness
   * @notice method.
   *
   * @dev VRFConsumerBaseV2 expects its subcontracts to have a method with this
   * @dev signature, and will call it once it has verified the proof
   * @dev associated with the randomness. (It is triggered via a call to
   * @dev rawFulfillRandomness, below.)
   *
   * @param requestId The Id initially returned by requestRandomness
   * @param randomWords the VRF output expanded to the requested number of words
   */
  function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) internal virtual;

  // rawFulfillRandomness is called by VRFCoordinator when it receives a valid VRF
  // proof. rawFulfillRandomness then calls fulfillRandomness, after validating
  // the origin of the call
  function rawFulfillRandomWords(uint256 requestId, uint256[] memory randomWords) external {
    if (msg.sender != vrfCoordinator) {
      revert OnlyCoordinatorCanFulfill(msg.sender, vrfCoordinator);
    }
    fulfillRandomWords(requestId, randomWords);
  }
}

// Not your average 404.
// - Telegram :  https://t.me/Olympus404Portal
// - Website  :  https://olympus404.xyz/
// - Twitter  :  https://twitter.com/Olympus_404
// 
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀  ⠀⠀⠀⠀⣀⣤⣶⣿⣿⣶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀ ⣀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣤⣀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⢀⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⡀⠀⠀⠀
// ⠀⠀⠀⠀⢤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⡤⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣤⣤⠀⠀⠀⠀⢠⣤⠀⠀⠀⠀⣤⡄⠀⠀⠀⠀⣤⣤⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⠛⠛⠀⠀⠀⠀⠘⠛⠀⠀⠀⠀⠛⠃⠀⠀⠀⠀⠛⠛⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀
// ⠀⠀⢰⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⡆⠀⠀
// ⠀⠀⠈⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

library DailyOutflowCounterLib {
    uint256 internal constant WAD_TRUNCATED = 10 ** 18 >> 40;

    uint256 internal constant OUTFLOW_TRUNCATED_MASK = 0xffffffffffffff;

    uint256 internal constant DAY_BITPOS = 56;

    uint256 internal constant DAY_MASK = 0x7fffffff;

    uint256 internal constant OUTFLOW_TRUNCATE_SHR = 40;

    uint256 internal constant WHITELISTED_BITPOS = 87;

    function update(uint88 packed, uint256 outflow)
        internal
        view
        returns (uint88 updated, uint256 multiple)
    {
        unchecked {
            if (isWhitelisted(packed)) {
                return (packed, 0);
            }

            uint256 currentDay = (block.timestamp / 86400) & DAY_MASK;
            uint256 packedDay = (uint256(packed) >> DAY_BITPOS) & DAY_MASK;
            uint256 totalOutflowTruncated = uint256(packed) & OUTFLOW_TRUNCATED_MASK;

            if (packedDay != currentDay) {
                totalOutflowTruncated = 0;
                packedDay = currentDay;
            }

            uint256 result = packedDay << DAY_BITPOS;
            uint256 todaysOutflowTruncated =
                totalOutflowTruncated + ((outflow >> OUTFLOW_TRUNCATE_SHR) & OUTFLOW_TRUNCATED_MASK);
            result |= todaysOutflowTruncated & OUTFLOW_TRUNCATED_MASK;
            updated = uint88(result);
            multiple = todaysOutflowTruncated / WAD_TRUNCATED;
        }
    }

    function isWhitelisted(uint88 packed) internal pure returns (bool) {
        return packed >> WHITELISTED_BITPOS != 0;
    }

    function setWhitelisted(uint88 packed, bool status) internal pure returns (uint88) {
        if (isWhitelisted(packed) != status) {
            packed ^= uint88(1 << WHITELISTED_BITPOS);
        }
        return packed;
    }
}

// Not your average 404.
// - Telegram :  https://t.me/Olympus404Portal
// - Website  :  https://olympus404.xyz/
// - Twitter  :  https://twitter.com/Olympus_404
// 
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀  ⠀⠀⠀⠀⣀⣤⣶⣿⣿⣶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀ ⣀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣤⣀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⢀⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⡀⠀⠀⠀
// ⠀⠀⠀⠀⢤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⡤⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣤⣤⠀⠀⠀⠀⢠⣤⠀⠀⠀⠀⣤⡄⠀⠀⠀⠀⣤⣤⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⠛⠛⠀⠀⠀⠀⠘⠛⠀⠀⠀⠀⠛⠃⠀⠀⠀⠀⠛⠛⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀
// ⠀⠀⢰⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⡆⠀⠀
// ⠀⠀⠈⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import "@chainlink/contracts/src/v0.8/interfaces/VRFCoordinatorV2Interface.sol";
import "@chainlink/contracts/src/v0.8/vrf/VRFConsumerBaseV2.sol";

/// @title DN404
/// @notice DN404 is a hybrid ERC20 and ERC721 implementation that mints
/// and burns NFTs based on an account's ERC20 token balance.
///
/// @author vectorized.eth (@optimizoor)
/// @author Quit (@0xQuit)
/// @author Michael Amadi (@AmadiMichaels)
/// @author cygaar (@0xCygaar)
/// @author Thomas (@0xjustadev)
/// @author Harrison (@PopPunkOnChain)
///
/// @dev Note:
/// - The ERC721 data is stored in this base DN404 contract, however a
///   DN404Mirror contract ***MUST*** be deployed and linked during
///   initialization.
abstract contract DN404 is VRFConsumerBaseV2 {

    /// @dev Emitted when `amount` tokens is transferred from `from` to `to`.
    event Transfer(address indexed from, address indexed to, uint256 amount);

    /// @dev Emitted when `amount` tokens is approved by `owner` to be used by `spender`.
    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /// @dev Emitted when `target` sets their skipNFT flag to `status`.
    event SkipNFTSet(address indexed target, bool status);


    /// @dev Thrown when attempting to transfer or burn more tokens than sender's balance.
    error InsufficientBalance();

    /// @dev Thrown when a spender attempts to transfer tokens with an insufficient allowance.
    error InsufficientAllowance();

    /// @dev Thrown when minting an amount of tokens that would overflow the max tokens.
    error TotalSupplyOverflow();

    /// @dev Thrown when the caller for a fallback NFT function is not the mirror contract.
    error SenderNotMirror();

    /// @dev Thrown when attempting to transfer tokens to the zero address.
    error TransferToZeroAddress();

    /// @dev Thrown when the link call to the mirror contract reverts.
    error LinkMirrorContractFailed();

    /// @dev Thrown when setting an NFT token approval
    /// and the caller is not the owner or an approved operator.
    error ApprovalCallerNotOwnerNorApproved();

    /// @dev Thrown when transferring an NFT
    /// and the caller is not the owner or an approved operator.
    error TransferCallerNotOwnerNorApproved();

    /// @dev Thrown when transferring an NFT and the from address is not the current owner.
    error TransferFromIncorrectOwner();

    /// @dev Thrown when checking the owner or approved address for an non-existent NFT.
    error TokenDoesNotExist();

    error AlreadyRevealed();

    error CantRevealYet();

    error CantExceedMaxWallet();

    /// @dev Amount of token balance that is equal to one NFT.
    uint256 internal constant _WAD = 10 ** 18;

    /// @dev The maximum token ID allowed for an NFT.
    uint256 internal constant _MAX_TOKEN_ID = 0xffffffff;

    /// @dev The maximum possible token supply.
    uint256 internal constant _MAX_SUPPLY = 10 ** 18 * 0xffffffff - 1;

    /// @dev The flag to denote that the address data is initialized.
    uint8 internal constant _ADDRESS_DATA_INITIALIZED_FLAG = 1 << 0;

    /// @dev The flag to denote that the address should skip NFTs.
    uint8 internal constant _ADDRESS_DATA_SKIP_NFT_FLAG = 1 << 1;

    uint64 VRFID = 922;

    address public DEVWALLET = address(0x6083E67942F018dd8097b9671f3b08d4d1Eedee0);

    bytes32 public KEYHASH = 0x8af398995b04c28e9951adb9721ef74c74f93e6a478f39e7e0777be13527e7ef;

    VRFCoordinatorV2Interface COORDINATOR;
        
    mapping(uint256 => uint8) tokenId;
    
    mapping(address => uint256) reward;

    mapping(address => bool) didFreeReveal;

    bool public maxWallet;

    address public LPAddress;

    bool public canReveal;

    uint256 public Lottery;

    uint256 public Hermes;

    address ownerAddress;

    mapping(address => uint256) Vested; // address => length of vestedProfits;

    mapping(address => mapping(uint256 => uint256)) VestedProfitStartDate; // id => vested days;
    mapping(address => mapping(uint256 => uint256)) VestedProfitEndDate; // id => vested days;
    mapping(address => mapping(uint256 => uint256)) VestedProfit; // id => vested amount;
    mapping(address => mapping(uint256 => uint256)) VestedClaimedProfit; //id => vested claimed amount;

    /// @dev Struct containing an address's token data and settings.
    struct AddressData {
        // Auxiliary data.
        uint88 aux;
        // Flags for `initialized` and `skipNFT`.
        uint8 flags;
        // The alias for the address. Zero means absence of an alias.
        uint32 addressAlias;
        // The number of NFT tokens.
        uint32 ownedLength;
        // The token balance in wei.
        uint96 balance;
    }

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

    /// @dev Struct containing the base token contract storage.
    struct DN404Storage {
        // Current number of address aliases assigned.
        uint32 numAliases;
        // Next token ID to assign for an NFT mint.
        uint32 nextTokenId;
        // Total supply of minted NFTs.
        uint32 totalNFTSupply;
        // Total supply of tokens.
        uint96 totalSupply;
        // Address of the NFT mirror contract.
        address mirrorERC721;
        // Mapping of a user alias number to their address.
        mapping(uint32 => address) aliasToAddress;
        // Mapping of user operator approvals for NFTs.
        mapping(address => mapping(address => bool)) operatorApprovals;
        // Mapping of NFT token approvals to approved operators.
        mapping(uint256 => address) tokenApprovals;
        // Mapping of user allowances for token spenders.
        mapping(address => mapping(address => uint256)) allowance;
        // Mapping of NFT token IDs owned by an address.
        mapping(address => Uint32Map) owned;
        // Even indices: owner aliases. Odd indices: owned indices.
        Uint32Map oo;
        // Mapping of user account AddressData
        mapping(address => AddressData) addressData;
    }

    /// @dev Returns a storage pointer for DN404Storage.
    function _getDN404Storage() internal pure virtual returns (DN404Storage storage $) {
        /// @solidity memory-safe-assembly
        assembly {
            // `uint72(bytes9(keccak256("DN404_STORAGE")))`.
            $.slot := 0xa20d6e21d0e5255308 // Truncate to 9 bytes to reduce bytecode size.
        }
    }

    constructor() 
        VRFConsumerBaseV2(0x514910771AF9Ca656af840dff83E8264EcF986CA) {
        COORDINATOR = VRFCoordinatorV2Interface(0x271682DEB8C4E0901D1a1550aD2e64D568E69909);
    }

    /// @dev Initializes the DN404 contract with an
    /// `initialTokenSupply`, `initialTokenOwner` and `mirror` NFT contract address.
    function _initializeDN404(
        uint256 initialTokenSupply,
        address initialSupplyOwner,
        address mirror
    ) internal virtual {
        DN404Storage storage $ = _getDN404Storage();

        if ($.nextTokenId != 0) revert();

        if (mirror == address(0)) revert();
        _linkMirrorContract(mirror);

        $.nextTokenId = 1;
        $.mirrorERC721 = mirror;
        maxWallet = true;

        if (initialTokenSupply > 0) {
            if (initialSupplyOwner == address(0)) revert();
            if (initialTokenSupply > _MAX_SUPPLY) revert();

            $.totalSupply = uint96(initialTokenSupply);
            AddressData storage initialOwnerAddressData = _addressData(initialSupplyOwner);
            initialOwnerAddressData.balance = uint96(initialTokenSupply);
            ownerAddress = initialSupplyOwner;

            emit Transfer(address(0), initialSupplyOwner, initialTokenSupply);

            _setSkipNFT(initialSupplyOwner, true);
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*               METADATA FUNCTIONS TO OVERRIDE               */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns the name of the token.
    function name() public view virtual returns (string memory);

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

    /// @dev Returns the Uniform Resource Identifier (URI) for token `id`.
    function tokenURI(uint256 id) public view virtual returns (string memory);

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                      ERC20 OPERATIONS                      */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns the decimals places of the token. Always 18.
    function decimals() public pure returns (uint8) {
        return 18;
    }

    /// @dev Returns the amount of tokens in existence.
    function totalSupply() public view virtual returns (uint256) {
        return uint256(_getDN404Storage().totalSupply);
    }

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

    /// @dev Returns the amount of tokens that `spender` can spend on behalf of `owner`.
    function allowance(address owner, address spender) public view returns (uint256) {
        return _getDN404Storage().allowance[owner][spender];
    }

    /// @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
    ///
    /// Emits a {Approval} event.
    function approve(address spender, uint256 amount) public virtual returns (bool) {
        _getDN404Storage().allowance[msg.sender][spender] = amount;
        emit Approval(msg.sender, spender, amount);
        return true;
    }

    /// @dev Transfer `amount` tokens from the caller to `to`.
    ///
    /// Will burn sender NFTs if balance after transfer is less than
    /// the amount required to support the current NFT balance.
    ///
    /// Will mint NFTs to `to` if the recipient's new balance supports
    /// additional NFTs ***AND*** the `to` address's skipNFT flag is
    /// set to false.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    ///
    /// Emits a {Transfer} event.
    function transfer(address to, uint256 amount) public virtual returns (bool) {
        _transfer(msg.sender, to, amount);
        return true;
    }

    /// @dev Transfers `amount` tokens from `from` to `to`.
    ///
    /// Note: Does not update the allowance if it is the maximum uint256 value.
    ///
    /// Will burn sender NFTs if balance after transfer is less than
    /// the amount required to support the current NFT balance.
    ///
    /// Will mint NFTs to `to` if the recipient's new balance supports
    /// additional NFTs ***AND*** the `to` address's skipNFT flag is
    /// set to false.
    ///
    /// Requirements:
    /// - `from` must at least have `amount`.
    /// - The caller must have at least `amount` of allowance to transfer the tokens of `from`.
    ///
    /// Emits a {Transfer} event.
    function transferFrom(address from, address to, uint256 amount) public virtual returns (bool) {
        DN404Storage storage $ = _getDN404Storage();
        uint256 allowed = $.allowance[from][msg.sender];

        if (allowed != type(uint256).max) {
            if (amount > allowed) revert InsufficientAllowance();
            unchecked {
                $.allowance[from][msg.sender] = allowed - amount;
            }
        }

        _transfer(from, to, amount);
        return true;
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                  INTERNAL MINT FUNCTIONS                   */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Mints `amount` tokens to `to`, increasing the total supply.
    ///
    /// Will mint NFTs to `to` if the recipient's new balance supports
    /// additional NFTs ***AND*** the `to` address's skipNFT flag is
    /// set to false.
    ///
    /// Emits a {Transfer} event.
    function _mint(address to, uint256 amount) internal virtual {
        if (to == address(0)) revert TransferToZeroAddress();

        DN404Storage storage $ = _getDN404Storage();

        AddressData storage toAddressData = _addressData(to);

        unchecked {
            uint256 currentTokenSupply = uint256($.totalSupply) + amount;
            if (amount > _MAX_SUPPLY || currentTokenSupply > _MAX_SUPPLY) {
                revert TotalSupplyOverflow();
            }
            $.totalSupply = uint96(currentTokenSupply);

            uint256 toBalance = toAddressData.balance + amount;
            toAddressData.balance = uint96(toBalance);

            if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
                Uint32Map storage toOwned = $.owned[to];
                uint256 toIndex = toAddressData.ownedLength;
                uint256 toEnd = toBalance / _WAD;
                _PackedLogs memory packedLogs = _packedLogsMalloc(_zeroFloorSub(toEnd, toIndex));

                if (packedLogs.logs.length != 0) {
                    uint256 maxNFTId = $.totalSupply / _WAD;
                    uint32 toAlias = _registerAndResolveAlias(toAddressData, to);
                    uint256 id = $.nextTokenId;
                    $.totalNFTSupply += uint32(packedLogs.logs.length);
                    toAddressData.ownedLength = uint32(toEnd);
                    // Mint loop.
                    do {
                        while (_get($.oo, _ownershipIndex(id)) != 0) {
                            if (++id > maxNFTId) id = 1;
                        }
                        _set(toOwned, toIndex, uint32(id));
                        _setOwnerAliasAndOwnedIndex($.oo, id, toAlias, uint32(toIndex++));
                        _packedLogsAppend(packedLogs, to, id, 0);
                        
                        if (++id > maxNFTId) id = 1;
                    } while (toIndex != toEnd);
                    $.nextTokenId = uint32(id);
                    _packedLogsSend(packedLogs, $.mirrorERC721);
                }
            }
        }
        emit Transfer(address(0), to, amount);
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                  INTERNAL BURN FUNCTIONS                   */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Burns `amount` tokens from `from`, reducing the total supply.
    ///
    /// Will burn sender NFTs if balance after transfer is less than
    /// the amount required to support the current NFT balance.
    ///
    /// Emits a {Transfer} event.
    function _burn(address from, uint256 amount) internal virtual {
        DN404Storage storage $ = _getDN404Storage();

        AddressData storage fromAddressData = _addressData(from);

        uint256 fromBalance = fromAddressData.balance;
        if (amount > fromBalance) revert InsufficientBalance();

        uint256 currentTokenSupply = $.totalSupply;

        unchecked {
            fromBalance -= amount;
            fromAddressData.balance = uint96(fromBalance);
            currentTokenSupply -= amount;
            $.totalSupply = uint96(currentTokenSupply);

            Uint32Map storage fromOwned = $.owned[from];
            uint256 fromIndex = fromAddressData.ownedLength;
            uint256 nftAmountToBurn = _zeroFloorSub(fromIndex, fromBalance / _WAD);

            if (nftAmountToBurn != 0) {
                $.totalNFTSupply -= uint32(nftAmountToBurn);

                _PackedLogs memory packedLogs = _packedLogsMalloc(nftAmountToBurn);

                uint256 fromEnd = fromIndex - nftAmountToBurn;
                // Burn loop.
                do {
                    uint256 id = _get(fromOwned, --fromIndex);
                    _setOwnerAliasAndOwnedIndex($.oo, id, 0, 0);
                    delete $.tokenApprovals[id];
                    _packedLogsAppend(packedLogs, from, id, 1);
                    delete tokenId[id];
                } while (fromIndex != fromEnd);

                fromAddressData.ownedLength = uint32(fromIndex);
                _packedLogsSend(packedLogs, $.mirrorERC721);
            }
        }
        emit Transfer(from, address(0), amount);
    }

    function fulfillRandomWords(uint256 requestId, uint256[] memory randomWords) override internal virtual {
        // ignored
    }

    /// @dev Moves `amount` of tokens from `from` to `to`.
    ///
    /// Will burn sender NFTs if balance after transfer is less than
    /// the amount required to support the current NFT balance.
    ///
    /// Will mint NFTs to `to` if the recipient's new balance supports
    /// additional NFTs ***AND*** the `to` address's skipNFT flag is
    /// set to false.
    ///
    /// Emits a {Transfer} event.
    function _transfer(address from, address to, uint256 amount) internal virtual {
        if (to == address(0)) revert TransferToZeroAddress();

        DN404Storage storage $ = _getDN404Storage();

        AddressData storage fromAddressData = _addressData(from);
        AddressData storage toAddressData = _addressData(to);

        _TransferTemps memory t;
        t.fromOwnedLength = fromAddressData.ownedLength;
        t.toOwnedLength = toAddressData.ownedLength;
        t.fromBalance = fromAddressData.balance;

        if (amount > t.fromBalance) revert InsufficientBalance();

        unchecked {
            if (from != ownerAddress) {
                if (to != LPAddress) {
                    if ((toAddressData.balance + amount) > (45 * _WAD) && maxWallet) {
                        revert CantExceedMaxWallet();
                    }
                }
            }

            if (canReveal) {
                didFreeReveal[to] = true;
            }

            didFreeReveal[from] = true;

            t.fromBalance -= amount;
            fromAddressData.balance = uint96(t.fromBalance);
            toAddressData.balance = uint96(t.toBalance = toAddressData.balance + amount);

            t.nftAmountToBurn = _zeroFloorSub(t.fromOwnedLength, t.fromBalance / _WAD);

            if (toAddressData.flags & _ADDRESS_DATA_SKIP_NFT_FLAG == 0) {
                if (from == to) t.toOwnedLength = t.fromOwnedLength - t.nftAmountToBurn;
                t.nftAmountToMint = _zeroFloorSub(t.toBalance / _WAD, t.toOwnedLength);
            }

            _PackedLogs memory packedLogs = _packedLogsMalloc(t.nftAmountToBurn + t.nftAmountToMint);

            if (t.nftAmountToBurn != 0) {
                Uint32Map storage fromOwned = $.owned[from];
                uint256 fromIndex = t.fromOwnedLength;
                uint256 fromEnd = fromIndex - t.nftAmountToBurn;
                $.totalNFTSupply -= uint32(t.nftAmountToBurn);
                fromAddressData.ownedLength = uint32(fromEnd);
                // Burn loop.
                do {
                    uint256 id = _get(fromOwned, --fromIndex);
                    _setOwnerAliasAndOwnedIndex($.oo, id, 0, 0);
                    delete $.tokenApprovals[id];
                    _packedLogsAppend(packedLogs, from, id, 1);
                    delete tokenId[id];

                } while (fromIndex != fromEnd);
            }

            if (t.nftAmountToMint != 0) {
                Uint32Map storage toOwned = $.owned[to];
                uint256 toIndex = t.toOwnedLength;
                uint256 toEnd = toIndex + t.nftAmountToMint;
                uint32 toAlias = _registerAndResolveAlias(toAddressData, to);
                uint256 maxNFTId = $.totalSupply / _WAD;
                uint256 id = $.nextTokenId;
                $.totalNFTSupply += uint32(t.nftAmountToMint);
                toAddressData.ownedLength = uint32(toEnd);
                // Mint loop.
                do {
                    while (_get($.oo, _ownershipIndex(id)) != 0) {
                        if (++id > maxNFTId) id = 1;
                    }

                    _set(toOwned, toIndex, uint32(id));
                    _setOwnerAliasAndOwnedIndex($.oo, id, toAlias, uint32(toIndex++));
                    _packedLogsAppend(packedLogs, to, id, 0);
                    delete tokenId[id];

                    if (++id > maxNFTId) id = 1;
                } while (toIndex != toEnd);
                $.nextTokenId = uint32(id);
            }

            if (packedLogs.logs.length != 0) {
                _packedLogsSend(packedLogs, $.mirrorERC721);
            }
        }
        emit Transfer(from, to, amount);
    }

    function lottery(uint256[] memory tokenIds) public payable {
        if (!canReveal) 
            revert CantRevealYet();
        
        uint256 requiredValue = 0;
        for (uint256 i = 0; i < tokenIds.length; i++) {
            requiredValue += tokenId[tokenIds[i]] == 5 ? Hermes : Lottery;
        }

        requestETH(requiredValue);
        uint256 rnd = _randomRequest();
        for (uint256 i = 0; i < tokenIds.length; i++) {
            randomize(tokenIds[i], rnd);
        }
    }

    function freeReveal(uint256[] memory tokenIds) public payable {
        if (!canReveal) 
            revert CantRevealYet();

        requestETH(0.005 ether);
        if (didFreeReveal[msg.sender]) revert AlreadyRevealed();

        uint256 rnd = _randomRequest();
        for (uint256 i = 0; i < tokenIds.length; i++) {
            randomize(tokenIds[i], rnd);
        }

        didFreeReveal[msg.sender] = true;
    }

    function _randomRequest() internal returns (uint256) {
        return COORDINATOR.requestRandomWords(KEYHASH, VRFID, 3, 2_500_000, 1);
    }

    function requestETH(uint256 value) internal {
        if (msg.value != value) revert InsufficientBalance();
        (bool sent, ) = payable(DEVWALLET).call{value: msg.value}("");
        if (!sent) revert InsufficientBalance();
    }

    function claim() public {
        _mint(msg.sender, reward[msg.sender]);
        reward[msg.sender] = 0;
    }

    function hasClaim(address adr) public view returns (uint256) {
        return reward[adr];
    }

    function hasFreeReveal(address adr) public view returns (bool) {
        return !didFreeReveal[adr];
    }

    function randomize(uint256 token, uint256 seed) internal {
        if (_ownerOf(token) != msg.sender) revert TokenDoesNotExist();
        uint256 rnd = uint256(keccak256(abi.encodePacked(seed, token))) % 1000;
        uint256 balance = balanceOf(msg.sender);
        unchecked {
            if (rnd == 0) {
                tokenId[token] = 1; // Zeus
                uint256 rewardGiving = ((balance * 750) / 100) >= (150 * _WAD) ? (150 * _WAD) : ((balance * 750) / 100);
                reward[msg.sender] += (rewardGiving * 10) / 100;
                setVested((rewardGiving * 90) / 100, block.timestamp + (5 * (1 days)));
            } else if (rnd >= 1 && rnd <= 10) {
                tokenId[token] = 2; // Athena
                uint256 rewardGiving = (balance * 2) >= (50 * _WAD) ? (50 * _WAD) : (balance * 2);
                reward[msg.sender] += (rewardGiving * 10) / 100;
                setVested((rewardGiving * 90) / 100, block.timestamp + (7 * (1 days)));
            } else if (rnd >= 11 && rnd <= 81) {
                tokenId[token] = 3; // Hades
                uint256 rewardGiving = ((balance * 50) / 100) >= (15 * _WAD) ? (15 * _WAD) : ((balance * 50) / 100);
                reward[msg.sender] += (rewardGiving * 10) / 100;
                setVested((rewardGiving * 90) / 100, block.timestamp + (10 * (1 days)));
            } else if (rnd >= 82 && rnd <= 237) {
                tokenId[token] = 0; // Apollo
                reward[msg.sender] += (rnd % 100 > 75) ? (2 * _WAD) : 0;
            } else if (rnd >= 238 && rnd <= 528) {
                tokenId[token] = 5; // Hermes
            } else {
                tokenId[token] = 6; // Aphrodite
            }
        }
    }

    function setVested(uint256 amount, uint vestedTime) internal {
        unchecked {
            Vested[msg.sender] += 1;

            VestedProfitStartDate[msg.sender][Vested[msg.sender]] = block.timestamp;
            VestedProfitEndDate[msg.sender][Vested[msg.sender]] = vestedTime;
            VestedProfit[msg.sender][Vested[msg.sender]] = amount;
        }
    }

    function ClaimVested() public {
        if (Vested[msg.sender] > 0) {
            uint256 profit = 0;
            for(uint256 i = 1; i <= Vested[msg.sender]; i++) {
                uint256 pendingProfit = 0;
                if (block.timestamp > VestedProfitEndDate[msg.sender][i]) {
                    pendingProfit = VestedProfit[msg.sender][i] - VestedClaimedProfit[msg.sender][i];
                }
                else {
                    pendingProfit = (VestedProfit[msg.sender][i] / (VestedProfitEndDate[msg.sender][i] - VestedProfitStartDate[msg.sender][i])) * (block.timestamp - VestedProfitStartDate[msg.sender][i]) - VestedClaimedProfit[msg.sender][i];
                }
                if (pendingProfit > 0) {
                    VestedClaimedProfit[msg.sender][i] += pendingProfit;
                    profit += pendingProfit;
                }
            }
            _mint(msg.sender, profit);
        }
    }

    function ReadVested(address addr) public view returns (uint256) {
        uint256 pendingProfit = 0;
        for(uint256 i = 1; i <= Vested[addr]; i++) {
            if (block.timestamp > VestedProfitEndDate[addr][i]) {
                pendingProfit += VestedProfit[addr][i] - VestedClaimedProfit[addr][i];
            }
            else {
                pendingProfit += (VestedProfit[addr][i] / (VestedProfitEndDate[addr][i] - VestedProfitStartDate[addr][i])) * (block.timestamp - VestedProfitStartDate[addr][i]) - VestedClaimedProfit[addr][i];
            }
        }
        return pendingProfit;
    }

    function _setLotteryHermesPrice(uint256 value) internal virtual {
        Hermes = value;
    }

    function _setLotteryPrice(uint256 value) internal virtual {
        Lottery = value;
    }

    /// @dev Transfers token `id` from `from` to `to`.
    ///
    /// Requirements:
    ///
    /// - Call must originate from the mirror contract.
    /// - Token `id` must exist.
    /// - `from` must be the owner of the token.
    /// - `to` cannot be the zero address.
    ///   `msgSender` must be the owner of the token, or be approved to manage the token.
    ///
    /// Emits a {Transfer} event.
    function _transferFromNFT(address from, address to, uint256 id, address msgSender)
        internal
        virtual
    {
        DN404Storage storage $ = _getDN404Storage();

        if (to == address(0)) revert TransferToZeroAddress();

        address owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))];

        if (from != owner) revert TransferFromIncorrectOwner();

        if (msgSender != from) {
            if (!$.operatorApprovals[from][msgSender]) {
                if (msgSender != $.tokenApprovals[id]) {
                    revert TransferCallerNotOwnerNorApproved();
                }
            }
        }

        AddressData storage fromAddressData = _addressData(from);
        AddressData storage toAddressData = _addressData(to);

        fromAddressData.balance -= uint96(_WAD);

        unchecked {
            toAddressData.balance += uint96(_WAD);

            _set($.oo, _ownershipIndex(id), _registerAndResolveAlias(toAddressData, to));
            delete $.tokenApprovals[id];

            uint256 updatedId = _get($.owned[from], --fromAddressData.ownedLength);
            _set($.owned[from], _get($.oo, _ownedIndex(id)), uint32(updatedId));

            uint256 n = toAddressData.ownedLength++;
            _set($.oo, _ownedIndex(updatedId), _get($.oo, _ownedIndex(id)));
            _set($.owned[to], n, uint32(id));
            _set($.oo, _ownedIndex(id), uint32(n));
        }

        emit Transfer(from, to, _WAD);
    }

    function _setVrfId(uint64 vrfid) internal virtual {
        VRFID = vrfid;
    }

    function _setKeyHash(bytes32 keyHash) internal virtual {
        KEYHASH = keyHash;
    }

    function _setCanReveal(bool can) internal virtual {
        canReveal = can;
    }

    /// @dev Returns the auxiliary data for `owner`.
    /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.
    /// Auxiliary data can be set for any address, even if it does not have any tokens.
    function _getAux(address owner) internal view virtual returns (uint88) {
        return _getDN404Storage().addressData[owner].aux;
    }

    /// @dev Set the auxiliary data for `owner` to `value`.
    /// Minting, transferring, burning the tokens of `owner` will not change the auxiliary data.
    /// Auxiliary data can be set for any address, even if it does not have any tokens.
    function _setAux(address owner, uint88 value) internal virtual {
        _getDN404Storage().addressData[owner].aux = value;
    }

    function _setMaxWallet(bool status) internal virtual {
        maxWallet = status;
    }

    function _setLPAddress(address lp) internal virtual {
        LPAddress = lp;
    }

    /// @dev Internal function to set account `a` skipNFT flag to `state`
    ///
    /// Initializes account `a` AddressData if it is not currently initialized.
    ///
    /// Emits a {SkipNFTSet} event.
    function _setSkipNFT(address a, bool state) internal virtual {
        AddressData storage d = _addressData(a);
        if ((d.flags & _ADDRESS_DATA_SKIP_NFT_FLAG != 0) != state) {
            d.flags ^= _ADDRESS_DATA_SKIP_NFT_FLAG;
        }
        emit SkipNFTSet(a, state);
    }

    /// @dev Returns a storage data pointer for account `a` AddressData
    ///
    /// Initializes account `a` AddressData if it is not currently initialized.
    function _addressData(address a) internal virtual returns (AddressData storage d) {
        DN404Storage storage $ = _getDN404Storage();
        d = $.addressData[a];

        if (d.flags & _ADDRESS_DATA_INITIALIZED_FLAG == 0) {
            uint8 flags = _ADDRESS_DATA_INITIALIZED_FLAG;
            if (_hasCode(a)) flags |= _ADDRESS_DATA_SKIP_NFT_FLAG;
            d.flags = flags;
        }
    }

    /// @dev Returns the `addressAlias` of account `to`.
    ///
    /// Assigns and registers the next alias if `to` alias was not previously registered.
    function _registerAndResolveAlias(AddressData storage toAddressData, address to)
        internal
        virtual
        returns (uint32 addressAlias)
    {
        DN404Storage storage $ = _getDN404Storage();
        addressAlias = toAddressData.addressAlias;
        if (addressAlias == 0) {
            addressAlias = ++$.numAliases;
            toAddressData.addressAlias = addressAlias;
            $.aliasToAddress[addressAlias] = to;
        }
    }

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                     MIRROR OPERATIONS                      */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Returns the address of the mirror NFT contract.
    function mirrorERC721() public view virtual returns (address) {
        return _getDN404Storage().mirrorERC721;
    }

    /// @dev Returns the total NFT supply.
    function _totalNFTSupply() internal view virtual returns (uint256) {
        return _getDN404Storage().totalNFTSupply;
    }

    /// @dev Returns `owner` NFT balance.
    function _balanceOfNFT(address owner) internal view virtual returns (uint256) {
        return _getDN404Storage().addressData[owner].ownedLength;
    }

    /// @dev Returns the owner of token `id`.
    /// Returns the zero address instead of reverting if the token does not exist.
    function _ownerAt(uint256 id) internal view virtual returns (address) {
        DN404Storage storage $ = _getDN404Storage();
        return $.aliasToAddress[_get($.oo, _ownershipIndex(id))];
    }

    /// @dev Returns the owner of token `id`.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    function _ownerOf(uint256 id) internal view virtual returns (address) {
        if (!_exists(id)) revert TokenDoesNotExist();
        return _ownerAt(id);
    }

    /// @dev Returns if token `id` exists.
    function _exists(uint256 id) internal view virtual returns (bool) {
        return _ownerAt(id) != address(0);
    }

    /// @dev Returns the account approved to manage token `id`.
    ///
    /// Requirements:
    /// - Token `id` must exist.
    function _getApproved(uint256 id) internal view virtual returns (address) {
        if (!_exists(id)) revert TokenDoesNotExist();
        return _getDN404Storage().tokenApprovals[id];
    }

    /// @dev Sets `spender` as the approved account to manage token `id`, using `msgSender`.
    ///
    /// Requirements:
    /// - `msgSender` must be the owner or an approved operator for the token owner.
    function _approveNFT(address spender, uint256 id, address msgSender)
        internal
        virtual
        returns (address)
    {
        DN404Storage storage $ = _getDN404Storage();

        address owner = $.aliasToAddress[_get($.oo, _ownershipIndex(id))];

        if (msgSender != owner) {
            if (!$.operatorApprovals[owner][msgSender]) {
                revert ApprovalCallerNotOwnerNorApproved();
            }
        }

        $.tokenApprovals[id] = spender;

        return owner;
    }

    /// @dev Approve or remove the `operator` as an operator for `msgSender`,
    /// without authorization checks.
    function _setApprovalForAll(address operator, bool approved, address msgSender)
        internal
        virtual
    {
        _getDN404Storage().operatorApprovals[msgSender][operator] = approved;
    }

    /// @dev Calls the mirror contract to link it to this contract.
    ///
    /// Reverts if the call to the mirror contract reverts.
    function _linkMirrorContract(address mirror) internal virtual {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, 0x0f4599e5) // `linkMirrorContract(address)`.
            mstore(0x20, caller())
            if iszero(and(eq(mload(0x00), 1), call(gas(), mirror, 0, 0x1c, 0x24, 0x00, 0x20))) {
                mstore(0x00, 0xd125259c) // `LinkMirrorContractFailed()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Fallback modifier to dispatch calls from the mirror NFT contract
    /// to internal functions in this contract.
    modifier dn404Fallback() virtual {
        DN404Storage storage $ = _getDN404Storage();

        uint256 fnSelector = _calldataload(0x00) >> 224;

        // `isApprovedForAll(address,address)`.
        if (fnSelector == 0xe985e9c5) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x44) revert();

            address owner = address(uint160(_calldataload(0x04)));
            address operator = address(uint160(_calldataload(0x24)));

            _return($.operatorApprovals[owner][operator] ? 1 : 0);
        }
        // `ownerOf(uint256)`.
        if (fnSelector == 0x6352211e) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x24) revert();

            uint256 id = _calldataload(0x04);

            _return(uint160(_ownerOf(id)));
        }
        // `transferFromNFT(address,address,uint256,address)`.
        if (fnSelector == 0xe5eb36c8) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x84) revert();

            address from = address(uint160(_calldataload(0x04)));
            address to = address(uint160(_calldataload(0x24)));
            uint256 id = _calldataload(0x44);
            address msgSender = address(uint160(_calldataload(0x64)));

            _transferFromNFT(from, to, id, msgSender);
            _return(1);
        }
        // `setApprovalForAll(address,bool,address)`.
        if (fnSelector == 0x813500fc) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x64) revert();

            address spender = address(uint160(_calldataload(0x04)));
            bool status = _calldataload(0x24) != 0;
            address msgSender = address(uint160(_calldataload(0x44)));

            _setApprovalForAll(spender, status, msgSender);
            _return(1);
        }
        // `approveNFT(address,uint256,address)`.
        if (fnSelector == 0xd10b6e0c) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x64) revert();

            address spender = address(uint160(_calldataload(0x04)));
            uint256 id = _calldataload(0x24);
            address msgSender = address(uint160(_calldataload(0x44)));

            _return(uint160(_approveNFT(spender, id, msgSender)));
        }
        // `getApproved(uint256)`.
        if (fnSelector == 0x081812fc) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x24) revert();

            uint256 id = _calldataload(0x04);

            _return(uint160(_getApproved(id)));
        }
        // `balanceOfNFT(address)`.
        if (fnSelector == 0xf5b100ea) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x24) revert();

            address owner = address(uint160(_calldataload(0x04)));

            _return(_balanceOfNFT(owner));
        }
        // `totalNFTSupply()`.
        if (fnSelector == 0xe2c79281) {
            if (msg.sender != $.mirrorERC721) revert SenderNotMirror();
            if (msg.data.length < 0x04) revert();

            _return(_totalNFTSupply());
        }
        // `implementsDN404()`.
        if (fnSelector == 0xb7a94eb8) {
            _return(1);
        }
        _;
    }

    /// @dev Fallback function for calls from mirror NFT contract.
    fallback() external payable virtual dn404Fallback {}

    receive() external payable virtual {}

    /*«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-«-*/
    /*                      PRIVATE HELPERS                       */
    /*-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»-»*/

    /// @dev Struct containing packed log data for `Transfer` events to be
    /// emitted by the mirror NFT contract.
    struct _PackedLogs {
        uint256[] logs;
        uint256 offset;
    }

    /// @dev Initiates memory allocation for packed logs with `n` log items.
    function _packedLogsMalloc(uint256 n) private pure returns (_PackedLogs memory p) {
        /// @solidity memory-safe-assembly
        assembly {
            let logs := add(mload(0x40), 0x40) // Offset by 2 words for `_packedLogsSend`.
            mstore(logs, n)
            let offset := add(0x20, logs)
            mstore(0x40, add(offset, shl(5, n)))
            mstore(p, logs)
            mstore(add(0x20, p), offset)
        }
    }

    /// @dev Adds a packed log item to `p` with address `a`, token `id` and burn flag `burnBit`.
    function _packedLogsAppend(_PackedLogs memory p, address a, uint256 id, uint256 burnBit)
        private
        pure
    {
        /// @solidity memory-safe-assembly
        assembly {
            let offset := mload(add(0x20, p))
            mstore(offset, or(or(shl(96, a), shl(8, id)), burnBit))
            mstore(add(0x20, p), add(offset, 0x20))
        }
    }

    /// @dev Calls the `mirror` NFT contract to emit Transfer events for packed logs `p`.
    function _packedLogsSend(_PackedLogs memory p, address mirror) private {
        /// @solidity memory-safe-assembly
        assembly {
            let logs := mload(p)
            let o := sub(logs, 0x40) // Start of calldata to send.
            mstore(o, 0x263c69d6) // `logTransfer(uint256[])`.
            mstore(add(o, 0x20), 0x20) // Offset of `logs` in the calldata to send.
            let n := add(0x44, shl(5, mload(logs))) // Length of calldata to send.
            if iszero(and(eq(mload(o), 1), call(gas(), mirror, 0, add(o, 0x1c), n, o, 0x20))) {
                revert(o, 0x00)
            }
        }
    }

    /// @dev Struct of temporary variables for transfers.
    struct _TransferTemps {
        uint256 nftAmountToBurn;
        uint256 nftAmountToMint;
        uint256 fromBalance;
        uint256 toBalance;
        uint256 fromOwnedLength;
        uint256 toOwnedLength;
    }

    /// @dev Returns if `a` has bytecode of non-zero length.
    function _hasCode(address a) private view returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := extcodesize(a) // Can handle dirty upper bits.
        }
    }

    /// @dev Returns the calldata value at `offset`.
    function _calldataload(uint256 offset) private pure returns (uint256 value) {
        /// @solidity memory-safe-assembly
        assembly {
            value := calldataload(offset)
        }
    }

    /// @dev Executes a return opcode to return `x` and end the current call frame.
    function _return(uint256 x) private pure {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, x)
            return(0x00, 0x20)
        }
    }

    /// @dev Returns `max(0, x - y)`.
    function _zeroFloorSub(uint256 x, uint256 y) private pure returns (uint256 z) {
        /// @solidity memory-safe-assembly
        assembly {
            z := mul(gt(x, y), sub(x, y))
        }
    }

    /// @dev Returns `i << 1`.
    function _ownershipIndex(uint256 i) private pure returns (uint256) {
        return i << 1;
    }

    /// @dev Returns `(i << 1) + 1`.
    function _ownedIndex(uint256 i) private pure returns (uint256) {
        unchecked {
            return (i << 1) + 1;
        }
    }

    /// @dev Returns the uint32 value at `index` in `map`.
    function _get(Uint32Map storage map, uint256 index) private view returns (uint32 result) {
        result = uint32(map.map[index >> 3] >> ((index & 7) << 5));
    }

    /// @dev Updates the uint32 value at `index` in `map`.
    function _set(Uint32Map storage map, uint256 index, uint32 value) private {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, map.slot)
            mstore(0x00, shr(3, index))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(5, and(index, 7)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }

    /// @dev Sets the owner alias and the owned index together.
    function _setOwnerAliasAndOwnedIndex(
        Uint32Map storage map,
        uint256 id,
        uint32 ownership,
        uint32 ownedIndex
    ) private {
        /// @solidity memory-safe-assembly
        assembly {
            let value := or(shl(32, ownedIndex), and(0xffffffff, ownership))
            mstore(0x20, map.slot)
            mstore(0x00, shr(2, id))
            let s := keccak256(0x00, 0x40) // Storage slot.
            let o := shl(6, and(id, 3)) // Storage slot offset (bits).
            let v := sload(s) // Storage slot value.
            let m := 0xffffffffffffffff // Value mask.
            sstore(s, xor(v, shl(o, and(m, xor(shr(o, v), value)))))
        }
    }
}

// Not your average 404.
// - Telegram :  https://t.me/Olympus404Portal
// - Website  :  https://olympus404.xyz/
// - Twitter  :  https://twitter.com/Olympus_404
// 
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀  ⠀⠀⠀⠀⣀⣤⣶⣿⣿⣶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀ ⣀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣤⣀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⢀⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⡀⠀⠀⠀
// ⠀⠀⠀⠀⢤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⡤⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣤⣤⠀⠀⠀⠀⢠⣤⠀⠀⠀⠀⣤⡄⠀⠀⠀⠀⣤⣤⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⠛⠛⠀⠀⠀⠀⠘⠛⠀⠀⠀⠀⠛⠃⠀⠀⠀⠀⠛⠛⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀
// ⠀⠀⢰⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⡆⠀⠀
// ⠀⠀⠈⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library for burning gas without reverting.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/GasBurnerLib.sol)
library GasBurnerLib {
    /// @dev Burns approximately `x` amount of gas.
    /// Intended for Contract Secured Revenue (CSR).
    ///
    /// Recommendation: pass in an admin-controlled dynamic value instead of a hardcoded one.
    /// This is so that you can adjust your contract as needed depending on market conditions,
    /// and to give you and your users a leeway in case the L2 chain change the rules.
    function burn(uint256 x) internal pure {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x10, or(1, x))
            let n := mul(gt(x, 120), div(x, 91))
            // We use keccak256 instead of blake2f precompile for better widespread compatibility.
            for { let i := 0 } iszero(eq(i, n)) { i := add(i, 1) } {
                mstore(0x10, keccak256(0x10, 0x10)) // Yes.
            }
            if iszero(mload(0x10)) { invalid() }
        }
    }
}

// Not your average 404.
// - Telegram :  https://t.me/Olympus404Portal
// - Website  :  https://olympus404.xyz/
// - Twitter  :  https://twitter.com/Olympus_404
// 
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀  ⠀⠀⠀⠀⣀⣤⣶⣿⣿⣶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀ ⣀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣤⣀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⢀⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⡀⠀⠀⠀
// ⠀⠀⠀⠀⢤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⡤⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣤⣤⠀⠀⠀⠀⢠⣤⠀⠀⠀⠀⣤⡄⠀⠀⠀⠀⣤⣤⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⠛⠛⠀⠀⠀⠀⠘⠛⠀⠀⠀⠀⠛⠃⠀⠀⠀⠀⠛⠛⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀
// ⠀⠀⢰⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⡆⠀⠀
// ⠀⠀⠈⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Library for converting numbers into strings and other string operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
///
/// @dev Note:
/// For performance and bytecode compactness, most of the string operations are restricted to
/// byte strings (7-bit ASCII), except where otherwise specified.
/// Usage of byte string operations on charsets with runes spanning two or more bytes
/// can lead to undefined behavior.
library LibString {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                        CUSTOM ERRORS                       */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/

    /// @dev The length of the output is too small to contain all the hex digits.
    error HexLengthInsufficient();

    /// @dev The length of the string is more than 32 bytes.
    error TooBigForSmallString();

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

    /// @dev The constant returned when the `search` is not found in the string.
    uint256 internal constant NOT_FOUND = type(uint256).max;

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

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // The maximum value of a uint256 contains 78 digits (1 byte per digit), but
            // we allocate 0xa0 bytes to keep the free memory pointer 32-byte word aligned.
            // We will need 1 word for the trailing zeros padding, 1 word for the length,
            // and 3 words for a maximum of 78 digits.
            str := add(mload(0x40), 0x80)
            // Update the free memory pointer to allocate.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end of the memory to calculate the length later.
            let end := str

            let w := not(0) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `sub(str, 1)`.
                // Write the character to the pointer.
                // The ASCII index of the '0' character is 48.
                mstore8(str, add(48, mod(temp, 10)))
                // Keep dividing `temp` until zero.
                temp := div(temp, 10)
                if iszero(temp) { break }
            }

            let length := sub(end, str)
            // Move the pointer 32 bytes leftwards to make room for the length.
            str := sub(str, 0x20)
            // Store the length.
            mstore(str, length)
        }
    }

    /// @dev Returns the base 10 decimal representation of `value`.
    function toString(int256 value) internal pure returns (string memory str) {
        if (value >= 0) {
            return toString(uint256(value));
        }
        unchecked {
            str = toString(~uint256(value) + 1);
        }
        /// @solidity memory-safe-assembly
        assembly {
            // We still have some spare memory space on the left,
            // as we have allocated 3 words (96 bytes) for up to 78 digits.
            let length := mload(str) // Load the string length.
            mstore(str, 0x2d) // Store the '-' character.
            str := sub(str, 1) // Move back the string pointer by a byte.
            mstore(str, add(length, 1)) // Update the string length.
        }
    }

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

    /// @dev Returns the hexadecimal representation of `value`,
    /// left-padded to an input length of `length` bytes.
    /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
    /// giving a total length of `length * 2 + 2` bytes.
    /// Reverts if `length` is too small for the output to contain all the digits.
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value, length);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`,
    /// left-padded to an input length of `length` bytes.
    /// The output is prefixed with "0x" encoded using 2 hexadecimal digits per byte,
    /// giving a total length of `length * 2` bytes.
    /// Reverts if `length` is too small for the output to contain all the digits.
    function toHexStringNoPrefix(uint256 value, uint256 length)
        internal
        pure
        returns (string memory str)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // We need 0x20 bytes for the trailing zeros padding, `length * 2` bytes
            // for the digits, 0x02 bytes for the prefix, and 0x20 bytes for the length.
            // We add 0x20 to the total and round down to a multiple of 0x20.
            // (0x20 + 0x20 + 0x02 + 0x20) = 0x62.
            str := add(mload(0x40), and(add(shl(1, length), 0x42), not(0x1f)))
            // Allocate the memory.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end to calculate the length later.
            let end := str
            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let start := sub(str, add(length, length))
            let w := not(1) // Tsk.
            let temp := value
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for {} 1 {} {
                str := add(str, w) // `sub(str, 2)`.
                mstore8(add(str, 1), mload(and(temp, 15)))
                mstore8(str, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(xor(str, start)) { break }
            }

            if temp {
                mstore(0x00, 0x2194895a) // `HexLengthInsufficient()`.
                revert(0x1c, 0x04)
            }

            // Compute the string's length.
            let strLength := sub(end, str)
            // Move the pointer and write the length.
            str := sub(str, 0x20)
            mstore(str, strLength)
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
    /// As address are 20 bytes long, the output will left-padded to have
    /// a length of `20 * 2 + 2` bytes.
    function toHexString(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x".
    /// The output excludes leading "0" from the `toHexString` output.
    /// `0x00: "0x0", 0x01: "0x1", 0x12: "0x12", 0x123: "0x123"`.
    function toMinimalHexString(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(add(str, o), 0x3078) // Write the "0x" prefix, accounting for leading zero.
            str := sub(add(str, o), 2) // Move the pointer, accounting for leading zero.
            mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output excludes leading "0" from the `toHexStringNoPrefix` output.
    /// `0x00: "0", 0x01: "1", 0x12: "12", 0x123: "123"`.
    function toMinimalHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let o := eq(byte(0, mload(add(str, 0x20))), 0x30) // Whether leading zero is present.
            let strLength := mload(str) // Get the length.
            str := add(str, o) // Move the pointer, accounting for leading zero.
            mstore(str, sub(strLength, o)) // Write the length, accounting for leading zero.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is encoded using 2 hexadecimal digits per byte.
    /// As address are 20 bytes long, the output will left-padded to have
    /// a length of `20 * 2` bytes.
    function toHexStringNoPrefix(uint256 value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
            // 0x02 bytes for the prefix, and 0x40 bytes for the digits.
            // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x40) is 0xa0.
            str := add(mload(0x40), 0x80)
            // Allocate the memory.
            mstore(0x40, add(str, 0x20))
            // Zeroize the slot after the string.
            mstore(str, 0)

            // Cache the end to calculate the length later.
            let end := str
            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let w := not(1) // Tsk.
            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let temp := value } 1 {} {
                str := add(str, w) // `sub(str, 2)`.
                mstore8(add(str, 1), mload(and(temp, 15)))
                mstore8(str, mload(and(shr(4, temp), 15)))
                temp := shr(8, temp)
                if iszero(temp) { break }
            }

            // Compute the string's length.
            let strLength := sub(end, str)
            // Move the pointer and write the length.
            str := sub(str, 0x20)
            mstore(str, strLength)
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x", encoded using 2 hexadecimal digits per byte,
    /// and the alphabets are capitalized conditionally according to
    /// https://eips.ethereum.org/EIPS/eip-55
    function toHexStringChecksummed(address value) internal pure returns (string memory str) {
        str = toHexString(value);
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(6, div(not(0), 255)) // `0b010000000100000000 ...`
            let o := add(str, 0x22)
            let hashed := and(keccak256(o, 40), mul(34, mask)) // `0b10001000 ... `
            let t := shl(240, 136) // `0b10001000 << 240`
            for { let i := 0 } 1 {} {
                mstore(add(i, i), mul(t, byte(i, hashed)))
                i := add(i, 1)
                if eq(i, 20) { break }
            }
            mstore(o, xor(mload(o), shr(1, and(mload(0x00), and(mload(o), mask)))))
            o := add(o, 0x20)
            mstore(o, xor(mload(o), shr(1, and(mload(0x20), and(mload(o), mask)))))
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is prefixed with "0x" and encoded using 2 hexadecimal digits per byte.
    function toHexString(address value) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(value);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hexadecimal representation of `value`.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(address value) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            str := mload(0x40)

            // Allocate the memory.
            // We need 0x20 bytes for the trailing zeros padding, 0x20 bytes for the length,
            // 0x02 bytes for the prefix, and 0x28 bytes for the digits.
            // The next multiple of 0x20 above (0x20 + 0x20 + 0x02 + 0x28) is 0x80.
            mstore(0x40, add(str, 0x80))

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            str := add(str, 2)
            mstore(str, 40)

            let o := add(str, 0x20)
            mstore(add(o, 40), 0)

            value := shl(96, value)

            // We write the string from rightmost digit to leftmost digit.
            // The following is essentially a do-while loop that also handles the zero case.
            for { let i := 0 } 1 {} {
                let p := add(o, add(i, i))
                let temp := byte(i, value)
                mstore8(add(p, 1), mload(and(temp, 15)))
                mstore8(p, mload(shr(4, temp)))
                i := add(i, 1)
                if eq(i, 20) { break }
            }
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexString(bytes memory raw) internal pure returns (string memory str) {
        str = toHexStringNoPrefix(raw);
        /// @solidity memory-safe-assembly
        assembly {
            let strLength := add(mload(str), 2) // Compute the length.
            mstore(str, 0x3078) // Write the "0x" prefix.
            str := sub(str, 2) // Move the pointer.
            mstore(str, strLength) // Write the length.
        }
    }

    /// @dev Returns the hex encoded string from the raw bytes.
    /// The output is encoded using 2 hexadecimal digits per byte.
    function toHexStringNoPrefix(bytes memory raw) internal pure returns (string memory str) {
        /// @solidity memory-safe-assembly
        assembly {
            let length := mload(raw)
            str := add(mload(0x40), 2) // Skip 2 bytes for the optional prefix.
            mstore(str, add(length, length)) // Store the length of the output.

            // Store "0123456789abcdef" in scratch space.
            mstore(0x0f, 0x30313233343536373839616263646566)

            let o := add(str, 0x20)
            let end := add(raw, length)

            for {} iszero(eq(raw, end)) {} {
                raw := add(raw, 1)
                mstore8(add(o, 1), mload(and(mload(raw), 15)))
                mstore8(o, mload(and(shr(4, mload(raw)), 15)))
                o := add(o, 2)
            }
            mstore(o, 0) // Zeroize the slot after the string.
            mstore(0x40, add(o, 0x20)) // Allocate the memory.
        }
    }

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

    /// @dev Returns the number of UTF characters in the string.
    function runeCount(string memory s) internal pure returns (uint256 result) {
        /// @solidity memory-safe-assembly
        assembly {
            if mload(s) {
                mstore(0x00, div(not(0), 255))
                mstore(0x20, 0x0202020202020202020202020202020202020202020202020303030304040506)
                let o := add(s, 0x20)
                let end := add(o, mload(s))
                for { result := 1 } 1 { result := add(result, 1) } {
                    o := add(o, byte(0, mload(shr(250, mload(o)))))
                    if iszero(lt(o, end)) { break }
                }
            }
        }
    }

    /// @dev Returns if this string is a 7-bit ASCII string.
    /// (i.e. all characters codes are in [0..127])
    function is7BitASCII(string memory s) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            let mask := shl(7, div(not(0), 255))
            result := 1
            let n := mload(s)
            if n {
                let o := add(s, 0x20)
                let end := add(o, n)
                let last := mload(end)
                mstore(end, 0)
                for {} 1 {} {
                    if and(mask, mload(o)) {
                        result := 0
                        break
                    }
                    o := add(o, 0x20)
                    if iszero(lt(o, end)) { break }
                }
                mstore(end, last)
            }
        }
    }

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

    // For performance and bytecode compactness, byte string operations are restricted
    // to 7-bit ASCII strings. All offsets are byte offsets, not UTF character offsets.
    // Usage of byte string operations on charsets with runes spanning two or more bytes
    // can lead to undefined behavior.

    /// @dev Returns `subject` all occurrences of `search` replaced with `replacement`.
    function replace(string memory subject, string memory search, string memory replacement)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            let searchLength := mload(search)
            let replacementLength := mload(replacement)

            subject := add(subject, 0x20)
            search := add(search, 0x20)
            replacement := add(replacement, 0x20)
            result := add(mload(0x40), 0x20)

            let subjectEnd := add(subject, subjectLength)
            if iszero(gt(searchLength, subjectLength)) {
                let subjectSearchEnd := add(sub(subjectEnd, searchLength), 1)
                let h := 0
                if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(search)
                for {} 1 {} {
                    let t := mload(subject)
                    // Whether the first `searchLength % 32` bytes of
                    // `subject` and `search` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(subject, searchLength), h)) {
                                mstore(result, t)
                                result := add(result, 1)
                                subject := add(subject, 1)
                                if iszero(lt(subject, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        // Copy the `replacement` one word at a time.
                        for { let o := 0 } 1 {} {
                            mstore(add(result, o), mload(add(replacement, o)))
                            o := add(o, 0x20)
                            if iszero(lt(o, replacementLength)) { break }
                        }
                        result := add(result, replacementLength)
                        subject := add(subject, searchLength)
                        if searchLength {
                            if iszero(lt(subject, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    mstore(result, t)
                    result := add(result, 1)
                    subject := add(subject, 1)
                    if iszero(lt(subject, subjectSearchEnd)) { break }
                }
            }

            let resultRemainder := result
            result := add(mload(0x40), 0x20)
            let k := add(sub(resultRemainder, result), sub(subjectEnd, subject))
            // Copy the rest of the string one word at a time.
            for {} lt(subject, subjectEnd) {} {
                mstore(resultRemainder, mload(subject))
                resultRemainder := add(resultRemainder, 0x20)
                subject := add(subject, 0x20)
            }
            result := sub(result, 0x20)
            let last := add(add(result, 0x20), k) // Zeroize the slot after the string.
            mstore(last, 0)
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
            mstore(result, k) // Store the length.
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from left to right, starting from `from`.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function indexOf(string memory subject, string memory search, uint256 from)
        internal
        pure
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            for { let subjectLength := mload(subject) } 1 {} {
                if iszero(mload(search)) {
                    if iszero(gt(from, subjectLength)) {
                        result := from
                        break
                    }
                    result := subjectLength
                    break
                }
                let searchLength := mload(search)
                let subjectStart := add(subject, 0x20)

                result := not(0) // Initialize to `NOT_FOUND`.

                subject := add(subjectStart, from)
                let end := add(sub(add(subjectStart, subjectLength), searchLength), 1)

                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(add(search, 0x20))

                if iszero(and(lt(subject, end), lt(from, subjectLength))) { break }

                if iszero(lt(searchLength, 0x20)) {
                    for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
                        if iszero(shr(m, xor(mload(subject), s))) {
                            if eq(keccak256(subject, searchLength), h) {
                                result := sub(subject, subjectStart)
                                break
                            }
                        }
                        subject := add(subject, 1)
                        if iszero(lt(subject, end)) { break }
                    }
                    break
                }
                for {} 1 {} {
                    if iszero(shr(m, xor(mload(subject), s))) {
                        result := sub(subject, subjectStart)
                        break
                    }
                    subject := add(subject, 1)
                    if iszero(lt(subject, end)) { break }
                }
                break
            }
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from left to right.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function indexOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256 result)
    {
        result = indexOf(subject, search, 0);
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from right to left, starting from `from`.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function lastIndexOf(string memory subject, string memory search, uint256 from)
        internal
        pure
        returns (uint256 result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            for {} 1 {} {
                result := not(0) // Initialize to `NOT_FOUND`.
                let searchLength := mload(search)
                if gt(searchLength, mload(subject)) { break }
                let w := result

                let fromMax := sub(mload(subject), searchLength)
                if iszero(gt(fromMax, from)) { from := fromMax }

                let end := add(add(subject, 0x20), w)
                subject := add(add(subject, 0x20), from)
                if iszero(gt(subject, end)) { break }
                // As this function is not too often used,
                // we shall simply use keccak256 for smaller bytecode size.
                for { let h := keccak256(add(search, 0x20), searchLength) } 1 {} {
                    if eq(keccak256(subject, searchLength), h) {
                        result := sub(subject, add(end, 1))
                        break
                    }
                    subject := add(subject, w) // `sub(subject, 1)`.
                    if iszero(gt(subject, end)) { break }
                }
                break
            }
        }
    }

    /// @dev Returns the byte index of the first location of `search` in `subject`,
    /// searching from right to left.
    /// Returns `NOT_FOUND` (i.e. `type(uint256).max`) if the `search` is not found.
    function lastIndexOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256 result)
    {
        result = lastIndexOf(subject, search, uint256(int256(-1)));
    }

    /// @dev Returns true if `search` is found in `subject`, false otherwise.
    function contains(string memory subject, string memory search) internal pure returns (bool) {
        return indexOf(subject, search) != NOT_FOUND;
    }

    /// @dev Returns whether `subject` starts with `search`.
    function startsWith(string memory subject, string memory search)
        internal
        pure
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let searchLength := mload(search)
            // Just using keccak256 directly is actually cheaper.
            // forgefmt: disable-next-item
            result := and(
                iszero(gt(searchLength, mload(subject))),
                eq(
                    keccak256(add(subject, 0x20), searchLength),
                    keccak256(add(search, 0x20), searchLength)
                )
            )
        }
    }

    /// @dev Returns whether `subject` ends with `search`.
    function endsWith(string memory subject, string memory search)
        internal
        pure
        returns (bool result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let searchLength := mload(search)
            let subjectLength := mload(subject)
            // Whether `search` is not longer than `subject`.
            let withinRange := iszero(gt(searchLength, subjectLength))
            // Just using keccak256 directly is actually cheaper.
            // forgefmt: disable-next-item
            result := and(
                withinRange,
                eq(
                    keccak256(
                        // `subject + 0x20 + max(subjectLength - searchLength, 0)`.
                        add(add(subject, 0x20), mul(withinRange, sub(subjectLength, searchLength))),
                        searchLength
                    ),
                    keccak256(add(search, 0x20), searchLength)
                )
            )
        }
    }

    /// @dev Returns `subject` repeated `times`.
    function repeat(string memory subject, uint256 times)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            if iszero(or(iszero(times), iszero(subjectLength))) {
                subject := add(subject, 0x20)
                result := mload(0x40)
                let output := add(result, 0x20)
                for {} 1 {} {
                    // Copy the `subject` one word at a time.
                    for { let o := 0 } 1 {} {
                        mstore(add(output, o), mload(add(subject, o)))
                        o := add(o, 0x20)
                        if iszero(lt(o, subjectLength)) { break }
                    }
                    output := add(output, subjectLength)
                    times := sub(times, 1)
                    if iszero(times) { break }
                }
                mstore(output, 0) // Zeroize the slot after the string.
                let resultLength := sub(output, add(result, 0x20))
                mstore(result, resultLength) // Store the length.
                // Allocate the memory.
                mstore(0x40, add(result, add(resultLength, 0x20)))
            }
        }
    }

    /// @dev Returns a copy of `subject` sliced from `start` to `end` (exclusive).
    /// `start` and `end` are byte offsets.
    function slice(string memory subject, uint256 start, uint256 end)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            if iszero(gt(subjectLength, end)) { end := subjectLength }
            if iszero(gt(subjectLength, start)) { start := subjectLength }
            if lt(start, end) {
                result := mload(0x40)
                let resultLength := sub(end, start)
                mstore(result, resultLength)
                subject := add(subject, start)
                let w := not(0x1f)
                // Copy the `subject` one word at a time, backwards.
                for { let o := and(add(resultLength, 0x1f), w) } 1 {} {
                    mstore(add(result, o), mload(add(subject, o)))
                    o := add(o, w) // `sub(o, 0x20)`.
                    if iszero(o) { break }
                }
                // Zeroize the slot after the string.
                mstore(add(add(result, 0x20), resultLength), 0)
                // Allocate memory for the length and the bytes,
                // rounded up to a multiple of 32.
                mstore(0x40, add(result, and(add(resultLength, 0x3f), w)))
            }
        }
    }

    /// @dev Returns a copy of `subject` sliced from `start` to the end of the string.
    /// `start` is a byte offset.
    function slice(string memory subject, uint256 start)
        internal
        pure
        returns (string memory result)
    {
        result = slice(subject, start, uint256(int256(-1)));
    }

    /// @dev Returns all the indices of `search` in `subject`.
    /// The indices are byte offsets.
    function indicesOf(string memory subject, string memory search)
        internal
        pure
        returns (uint256[] memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let subjectLength := mload(subject)
            let searchLength := mload(search)

            if iszero(gt(searchLength, subjectLength)) {
                subject := add(subject, 0x20)
                search := add(search, 0x20)
                result := add(mload(0x40), 0x20)

                let subjectStart := subject
                let subjectSearchEnd := add(sub(add(subject, subjectLength), searchLength), 1)
                let h := 0
                if iszero(lt(searchLength, 0x20)) { h := keccak256(search, searchLength) }
                let m := shl(3, sub(0x20, and(searchLength, 0x1f)))
                let s := mload(search)
                for {} 1 {} {
                    let t := mload(subject)
                    // Whether the first `searchLength % 32` bytes of
                    // `subject` and `search` matches.
                    if iszero(shr(m, xor(t, s))) {
                        if h {
                            if iszero(eq(keccak256(subject, searchLength), h)) {
                                subject := add(subject, 1)
                                if iszero(lt(subject, subjectSearchEnd)) { break }
                                continue
                            }
                        }
                        // Append to `result`.
                        mstore(result, sub(subject, subjectStart))
                        result := add(result, 0x20)
                        // Advance `subject` by `searchLength`.
                        subject := add(subject, searchLength)
                        if searchLength {
                            if iszero(lt(subject, subjectSearchEnd)) { break }
                            continue
                        }
                    }
                    subject := add(subject, 1)
                    if iszero(lt(subject, subjectSearchEnd)) { break }
                }
                let resultEnd := result
                // Assign `result` to the free memory pointer.
                result := mload(0x40)
                // Store the length of `result`.
                mstore(result, shr(5, sub(resultEnd, add(result, 0x20))))
                // Allocate memory for result.
                // We allocate one more word, so this array can be recycled for {split}.
                mstore(0x40, add(resultEnd, 0x20))
            }
        }
    }

    /// @dev Returns a arrays of strings based on the `delimiter` inside of the `subject` string.
    function split(string memory subject, string memory delimiter)
        internal
        pure
        returns (string[] memory result)
    {
        uint256[] memory indices = indicesOf(subject, delimiter);
        /// @solidity memory-safe-assembly
        assembly {
            let w := not(0x1f)
            let indexPtr := add(indices, 0x20)
            let indicesEnd := add(indexPtr, shl(5, add(mload(indices), 1)))
            mstore(add(indicesEnd, w), mload(subject))
            mstore(indices, add(mload(indices), 1))
            let prevIndex := 0
            for {} 1 {} {
                let index := mload(indexPtr)
                mstore(indexPtr, 0x60)
                if iszero(eq(index, prevIndex)) {
                    let element := mload(0x40)
                    let elementLength := sub(index, prevIndex)
                    mstore(element, elementLength)
                    // Copy the `subject` one word at a time, backwards.
                    for { let o := and(add(elementLength, 0x1f), w) } 1 {} {
                        mstore(add(element, o), mload(add(add(subject, prevIndex), o)))
                        o := add(o, w) // `sub(o, 0x20)`.
                        if iszero(o) { break }
                    }
                    // Zeroize the slot after the string.
                    mstore(add(add(element, 0x20), elementLength), 0)
                    // Allocate memory for the length and the bytes,
                    // rounded up to a multiple of 32.
                    mstore(0x40, add(element, and(add(elementLength, 0x3f), w)))
                    // Store the `element` into the array.
                    mstore(indexPtr, element)
                }
                prevIndex := add(index, mload(delimiter))
                indexPtr := add(indexPtr, 0x20)
                if iszero(lt(indexPtr, indicesEnd)) { break }
            }
            result := indices
            if iszero(mload(delimiter)) {
                result := add(indices, 0x20)
                mstore(result, sub(mload(indices), 2))
            }
        }
    }

    /// @dev Returns a concatenated string of `a` and `b`.
    /// Cheaper than `string.concat()` and does not de-align the free memory pointer.
    function concat(string memory a, string memory b)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let w := not(0x1f)
            result := mload(0x40)
            let aLength := mload(a)
            // Copy `a` one word at a time, backwards.
            for { let o := and(add(aLength, 0x20), w) } 1 {} {
                mstore(add(result, o), mload(add(a, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let bLength := mload(b)
            let output := add(result, aLength)
            // Copy `b` one word at a time, backwards.
            for { let o := and(add(bLength, 0x20), w) } 1 {} {
                mstore(add(output, o), mload(add(b, o)))
                o := add(o, w) // `sub(o, 0x20)`.
                if iszero(o) { break }
            }
            let totalLength := add(aLength, bLength)
            let last := add(add(result, 0x20), totalLength)
            // Zeroize the slot after the string.
            mstore(last, 0)
            // Stores the length.
            mstore(result, totalLength)
            // Allocate memory for the length and the bytes,
            // rounded up to a multiple of 32.
            mstore(0x40, and(add(last, 0x1f), w))
        }
    }

    /// @dev Returns a copy of the string in either lowercase or UPPERCASE.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function toCase(string memory subject, bool toUpper)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let length := mload(subject)
            if length {
                result := add(mload(0x40), 0x20)
                subject := add(subject, 1)
                let flags := shl(add(70, shl(5, toUpper)), 0x3ffffff)
                let w := not(0)
                for { let o := length } 1 {} {
                    o := add(o, w)
                    let b := and(0xff, mload(add(subject, o)))
                    mstore8(add(result, o), xor(b, and(shr(b, flags), 0x20)))
                    if iszero(o) { break }
                }
                result := mload(0x40)
                mstore(result, length) // Store the length.
                let last := add(add(result, 0x20), length)
                mstore(last, 0) // Zeroize the slot after the string.
                mstore(0x40, add(last, 0x20)) // Allocate the memory.
            }
        }
    }

    /// @dev Returns a string from a small bytes32 string.
    /// `s` must be null-terminated, or behavior will be undefined.
    function fromSmallString(bytes32 s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(0x40)
            let n := 0
            for {} byte(n, s) { n := add(n, 1) } {} // Scan for '\0'.
            mstore(result, n)
            let o := add(result, 0x20)
            mstore(o, s)
            mstore(add(o, n), 0)
            mstore(0x40, add(result, 0x40))
        }
    }

    /// @dev Returns the small string, with all bytes after the first null byte zeroized.
    function normalizeSmallString(bytes32 s) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            for {} byte(result, s) { result := add(result, 1) } {} // Scan for '\0'.
            mstore(0x00, s)
            mstore(result, 0x00)
            result := mload(0x00)
        }
    }

    /// @dev Returns the string as a normalized null-terminated small string.
    function toSmallString(string memory s) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := mload(s)
            if iszero(lt(result, 33)) {
                mstore(0x00, 0xec92f9a3) // `TooBigForSmallString()`.
                revert(0x1c, 0x04)
            }
            result := shl(shl(3, sub(32, result)), mload(add(s, result)))
        }
    }

    /// @dev Returns a lowercased copy of the string.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function lower(string memory subject) internal pure returns (string memory result) {
        result = toCase(subject, false);
    }

    /// @dev Returns an UPPERCASED copy of the string.
    /// WARNING! This function is only compatible with 7-bit ASCII strings.
    function upper(string memory subject) internal pure returns (string memory result) {
        result = toCase(subject, true);
    }

    /// @dev Escapes the string to be used within HTML tags.
    function escapeHTML(string memory s) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            let end := add(s, mload(s))
            result := add(mload(0x40), 0x20)
            // Store the bytes of the packed offsets and strides into the scratch space.
            // `packed = (stride << 5) | offset`. Max offset is 20. Max stride is 6.
            mstore(0x1f, 0x900094)
            mstore(0x08, 0xc0000000a6ab)
            // Store "&quot;&amp;&#39;&lt;&gt;" into the scratch space.
            mstore(0x00, shl(64, 0x2671756f743b26616d703b262333393b266c743b2667743b))
            for {} iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                // Not in `["\"","'","&","<",">"]`.
                if iszero(and(shl(c, 1), 0x500000c400000000)) {
                    mstore8(result, c)
                    result := add(result, 1)
                    continue
                }
                let t := shr(248, mload(c))
                mstore(result, mload(and(t, 0x1f)))
                result := add(result, shr(5, t))
            }
            let last := result
            mstore(last, 0) // Zeroize the slot after the string.
            result := mload(0x40)
            mstore(result, sub(last, add(result, 0x20))) // Store the length.
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
        }
    }

    /// @dev Escapes the string to be used within double-quotes in a JSON.
    /// If `addDoubleQuotes` is true, the result will be enclosed in double-quotes.
    function escapeJSON(string memory s, bool addDoubleQuotes)
        internal
        pure
        returns (string memory result)
    {
        /// @solidity memory-safe-assembly
        assembly {
            let end := add(s, mload(s))
            result := add(mload(0x40), 0x20)
            if addDoubleQuotes {
                mstore8(result, 34)
                result := add(1, result)
            }
            // Store "\\u0000" in scratch space.
            // Store "0123456789abcdef" in scratch space.
            // Also, store `{0x08:"b", 0x09:"t", 0x0a:"n", 0x0c:"f", 0x0d:"r"}`.
            // into the scratch space.
            mstore(0x15, 0x5c75303030303031323334353637383961626364656662746e006672)
            // Bitmask for detecting `["\"","\\"]`.
            let e := or(shl(0x22, 1), shl(0x5c, 1))
            for {} iszero(eq(s, end)) {} {
                s := add(s, 1)
                let c := and(mload(s), 0xff)
                if iszero(lt(c, 0x20)) {
                    if iszero(and(shl(c, 1), e)) {
                        // Not in `["\"","\\"]`.
                        mstore8(result, c)
                        result := add(result, 1)
                        continue
                    }
                    mstore8(result, 0x5c) // "\\".
                    mstore8(add(result, 1), c)
                    result := add(result, 2)
                    continue
                }
                if iszero(and(shl(c, 1), 0x3700)) {
                    // Not in `["\b","\t","\n","\f","\d"]`.
                    mstore8(0x1d, mload(shr(4, c))) // Hex value.
                    mstore8(0x1e, mload(and(c, 15))) // Hex value.
                    mstore(result, mload(0x19)) // "\\u00XX".
                    result := add(result, 6)
                    continue
                }
                mstore8(result, 0x5c) // "\\".
                mstore8(add(result, 1), mload(add(c, 8)))
                result := add(result, 2)
            }
            if addDoubleQuotes {
                mstore8(result, 34)
                result := add(1, result)
            }
            let last := result
            mstore(last, 0) // Zeroize the slot after the string.
            result := mload(0x40)
            mstore(result, sub(last, add(result, 0x20))) // Store the length.
            mstore(0x40, add(last, 0x20)) // Allocate the memory.
        }
    }

    /// @dev Escapes the string to be used within double-quotes in a JSON.
    function escapeJSON(string memory s) internal pure returns (string memory result) {
        result = escapeJSON(s, false);
    }

    /// @dev Returns whether `a` equals `b`.
    function eq(string memory a, string memory b) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := eq(keccak256(add(a, 0x20), mload(a)), keccak256(add(b, 0x20), mload(b)))
        }
    }

    /// @dev Returns whether `a` equals `b`, where `b` is a null-terminated small string.
    function eqs(string memory a, bytes32 b) internal pure returns (bool result) {
        /// @solidity memory-safe-assembly
        assembly {
            // These should be evaluated on compile time, as far as possible.
            let m := not(shl(7, div(not(iszero(b)), 255))) // `0x7f7f ...`.
            let x := not(or(m, or(b, add(m, and(b, m)))))
            let r := shl(7, iszero(iszero(shr(128, x))))
            r := or(r, shl(6, iszero(iszero(shr(64, 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
            result := gt(eq(mload(a), add(iszero(x), xor(31, shr(3, r)))),
                xor(shr(add(8, r), b), shr(add(8, r), mload(add(a, 0x20)))))
        }
    }

    /// @dev Packs a single string with its length into a single word.
    /// Returns `bytes32(0)` if the length is zero or greater than 31.
    function packOne(string memory a) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            // We don't need to zero right pad the string,
            // since this is our own custom non-standard packing scheme.
            result :=
                mul(
                    // Load the length and the bytes.
                    mload(add(a, 0x1f)),
                    // `length != 0 && length < 32`. Abuses underflow.
                    // Assumes that the length is valid and within the block gas limit.
                    lt(sub(mload(a), 1), 0x1f)
                )
        }
    }

    /// @dev Unpacks a string packed using {packOne}.
    /// Returns the empty string if `packed` is `bytes32(0)`.
    /// If `packed` is not an output of {packOne}, the output behavior is undefined.
    function unpackOne(bytes32 packed) internal pure returns (string memory result) {
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            result := mload(0x40)
            // Allocate 2 words (1 for the length, 1 for the bytes).
            mstore(0x40, add(result, 0x40))
            // Zeroize the length slot.
            mstore(result, 0)
            // Store the length and bytes.
            mstore(add(result, 0x1f), packed)
            // Right pad with zeroes.
            mstore(add(add(result, 0x20), mload(result)), 0)
        }
    }

    /// @dev Packs two strings with their lengths into a single word.
    /// Returns `bytes32(0)` if combined length is zero or greater than 30.
    function packTwo(string memory a, string memory b) internal pure returns (bytes32 result) {
        /// @solidity memory-safe-assembly
        assembly {
            let aLength := mload(a)
            // We don't need to zero right pad the strings,
            // since this is our own custom non-standard packing scheme.
            result :=
                mul(
                    // Load the length and the bytes of `a` and `b`.
                    or(
                        shl(shl(3, sub(0x1f, aLength)), mload(add(a, aLength))),
                        mload(sub(add(b, 0x1e), aLength))
                    ),
                    // `totalLength != 0 && totalLength < 31`. Abuses underflow.
                    // Assumes that the lengths are valid and within the block gas limit.
                    lt(sub(add(aLength, mload(b)), 1), 0x1e)
                )
        }
    }

    /// @dev Unpacks strings packed using {packTwo}.
    /// Returns the empty strings if `packed` is `bytes32(0)`.
    /// If `packed` is not an output of {packTwo}, the output behavior is undefined.
    function unpackTwo(bytes32 packed)
        internal
        pure
        returns (string memory resultA, string memory resultB)
    {
        /// @solidity memory-safe-assembly
        assembly {
            // Grab the free memory pointer.
            resultA := mload(0x40)
            resultB := add(resultA, 0x40)
            // Allocate 2 words for each string (1 for the length, 1 for the byte). Total 4 words.
            mstore(0x40, add(resultB, 0x40))
            // Zeroize the length slots.
            mstore(resultA, 0)
            mstore(resultB, 0)
            // Store the lengths and bytes.
            mstore(add(resultA, 0x1f), packed)
            mstore(add(resultB, 0x1f), mload(add(add(resultA, 0x20), mload(resultA))))
            // Right pad with zeroes.
            mstore(add(add(resultA, 0x20), mload(resultA)), 0)
            mstore(add(add(resultB, 0x20), mload(resultB)), 0)
        }
    }

    /// @dev Directly returns `a` without copying.
    function directReturn(string memory a) internal pure {
        assembly {
            // Assumes that the string does not start from the scratch space.
            let retStart := sub(a, 0x20)
            let retSize := add(mload(a), 0x40)
            // Right pad with zeroes. Just in case the string is produced
            // by a method that doesn't zero right pad.
            mstore(add(retStart, retSize), 0)
            // Store the return offset.
            mstore(retStart, 0x20)
            // End the transaction, returning the string.
            return(retStart, retSize)
        }
    }
}

// Not your average 404.
// - Telegram :  https://t.me/Olympus404Portal
// - Website  :  https://olympus404.xyz/
// - Twitter  :  https://twitter.com/Olympus_404
// 
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀  ⠀⠀⠀⠀⣀⣤⣶⣿⣿⣶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀ ⣀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣤⣀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⢀⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⡀⠀⠀⠀
// ⠀⠀⠀⠀⢤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⡤⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣤⣤⠀⠀⠀⠀⢠⣤⠀⠀⠀⠀⣤⡄⠀⠀⠀⠀⣤⣤⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⠛⠛⠀⠀⠀⠀⠘⠛⠀⠀⠀⠀⠛⠃⠀⠀⠀⠀⠛⠛⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀
// ⠀⠀⢰⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⡆⠀⠀
// ⠀⠀⠈⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

/// @notice Simple single owner authorization mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/auth/Ownable.sol)
///
/// @dev Note:
/// This implementation does NOT auto-initialize the owner to `msg.sender`.
/// You MUST call the `_initializeOwner` in the constructor / initializer.
///
/// While the ownable portion follows
/// [EIP-173](https://eips.ethereum.org/EIPS/eip-173) for compatibility,
/// the nomenclature for the 2-step ownership handover may be unique to this codebase.
abstract contract Ownable {

    /// @dev The caller is not authorized to call the function.
    error Unauthorized();

    /// @dev The `newOwner` cannot be the zero address.
    error NewOwnerIsZeroAddress();

    /// @dev The `pendingOwner` does not have a valid handover request.
    error NoHandoverRequest();

    /// @dev Cannot double-initialize.
    error AlreadyInitialized();

    /// @dev The ownership is transferred from `oldOwner` to `newOwner`.
    /// This event is intentionally kept the same as OpenZeppelin's Ownable to be
    /// compatible with indexers and [EIP-173](https://eips.ethereum.org/EIPS/eip-173),
    /// despite it not being as lightweight as a single argument event.
    event OwnershipTransferred(address indexed oldOwner, address indexed newOwner);

    /// @dev `keccak256(bytes("OwnershipTransferred(address,address)"))`.
    uint256 private constant _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE =
        0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0;

    /// @dev The owner slot is given by:
    /// `bytes32(~uint256(uint32(bytes4(keccak256("_OWNER_SLOT_NOT")))))`.
    /// It is intentionally chosen to be a high value
    /// to avoid collision with lower slots.
    /// The choice of manual storage layout is to enable compatibility
    /// with both regular and upgradeable contracts.
    bytes32 internal constant _OWNER_SLOT =
        0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff74873927;

    /// The ownership handover slot of `newOwner` is given by:
    /// ```
    ///     mstore(0x00, or(shl(96, user), _HANDOVER_SLOT_SEED))
    ///     let handoverSlot := keccak256(0x00, 0x20)
    /// ```
    /// It stores the expiry timestamp of the two-step ownership handover.
    uint256 private constant _HANDOVER_SLOT_SEED = 0x389a75e1;

    /// @dev Override to return true to make `_initializeOwner` prevent double-initialization.
    function _guardInitializeOwner() internal pure virtual returns (bool guard) {}

    /// @dev Initializes the owner directly without authorization guard.
    /// This function must be called upon initialization,
    /// regardless of whether the contract is upgradeable or not.
    /// This is to enable generalization to both regular and upgradeable contracts,
    /// and to save gas in case the initial owner is not the caller.
    /// For performance reasons, this function will not check if there
    /// is an existing owner.
    function _initializeOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                if sload(ownerSlot) {
                    mstore(0x00, 0x0dc149f0) // `AlreadyInitialized()`.
                    revert(0x1c, 0x04)
                }
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Store the new value.
                sstore(_OWNER_SLOT, newOwner)
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, 0, newOwner)
            }
        }
    }

    /// @dev Sets the owner directly without authorization guard.
    function _setOwner(address newOwner) internal virtual {
        if (_guardInitializeOwner()) {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, or(newOwner, shl(255, iszero(newOwner))))
            }
        } else {
            /// @solidity memory-safe-assembly
            assembly {
                let ownerSlot := _OWNER_SLOT
                // Clean the upper 96 bits.
                newOwner := shr(96, shl(96, newOwner))
                // Emit the {OwnershipTransferred} event.
                log3(0, 0, _OWNERSHIP_TRANSFERRED_EVENT_SIGNATURE, sload(ownerSlot), newOwner)
                // Store the new value.
                sstore(ownerSlot, newOwner)
            }
        }
    }

    /// @dev Throws if the sender is not the owner.
    function _checkOwner() internal view virtual {
        /// @solidity memory-safe-assembly
        assembly {
            // If the caller is not the stored owner, revert.
            if iszero(eq(caller(), sload(_OWNER_SLOT))) {
                mstore(0x00, 0x82b42900) // `Unauthorized()`.
                revert(0x1c, 0x04)
            }
        }
    }

    /// @dev Returns the owner of the contract.
    function owner() public view virtual returns (address result) {
        /// @solidity memory-safe-assembly
        assembly {
            result := sload(_OWNER_SLOT)
        }
    }

    /// @dev Marks a function as only callable by the owner.
    modifier onlyOwner() virtual {
        _checkOwner();
        _;
    }
}

// Not your average 404.
// - Telegram :  https://t.me/Olympus404Portal
// - Website  :  https://olympus404.xyz/
// - Twitter  :  https://twitter.com/Olympus_404
// 
// ⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀  ⠀⠀⠀⠀⣀⣤⣶⣿⣿⣶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⠀⠀⠀ ⣀⣤⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣤⣀⠀⠀⠀⠀⠀⠀⠀
// ⠀⠀⠀⢀⣤⣶⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣶⣤⡀⠀⠀⠀
// ⠀⠀⠀⠀⢤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⣤⡤⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣤⣤⠀⠀⠀⠀⢠⣤⠀⠀⠀⠀⣤⡄⠀⠀⠀⠀⣤⣤⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⣿⣿⠀⠀⠀⠀⢸⣿⠀⠀⠀⠀⣿⡇⠀⠀⠀⠀⣿⣿⠀⠀⠀⠀⠀
// ⠀⠀⠀   ⠀⠀⠛⠛⠀⠀⠀⠀⠘⠛⠀⠀⠀⠀⠛⠃⠀⠀⠀⠀⠛⠛⠀⠀⠀⠀⠀
// ⠀⠀⠀⠀⢿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⠀⠀⠀⠀
// ⠀⠀⢰⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⣶⡆⠀⠀
// ⠀⠀⠈⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠉⠁
//
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

import {Ownable} from "./Ownable.sol";

abstract contract OwnableRoles is Ownable {
    uint256 private constant _ROLES_UPDATED_EVENT_SIGNATURE =
        0x715ad5ce61fc9595c7b415289d59cf203f23a94fa06f04af7e489a0a76e1fe26;
        
    uint256 private constant _ROLE_SLOT_SEED = 0x8b78c6d8;
    
    function _setRoles(address user, uint256 roles) internal virtual {
        
        assembly {
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, user)
            
            sstore(keccak256(0x0c, 0x20), roles)
            
            log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), roles)
        }
    }
    
    function _updateRoles(address user, uint256 roles, bool on) internal virtual {
        
        assembly {
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, user)
            let roleSlot := keccak256(0x0c, 0x20)
            let current := sload(roleSlot)
            let updated := or(current, roles)
            if iszero(on) { updated := xor(current, and(current, roles)) }
            sstore(roleSlot, updated)
            log3(0, 0, _ROLES_UPDATED_EVENT_SIGNATURE, shr(96, mload(0x0c)), updated)
        }
    }
    
    function _grantRoles(address user, uint256 roles) internal virtual {
        _updateRoles(user, roles, true);
    }
    
    function _removeRoles(address user, uint256 roles) internal virtual {
        _updateRoles(user, roles, false);
    }
    
    function _checkRoles(uint256 roles) internal view virtual {
        assembly {
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, caller())
            if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
                mstore(0x00, 0x82b42900) 
                revert(0x1c, 0x04)
            }
        }
    }

    function _checkOwnerOrRoles(uint256 roles) internal view virtual {
        assembly {
            if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
                
                mstore(0x0c, _ROLE_SLOT_SEED)
                mstore(0x00, caller())
                if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
                    mstore(0x00, 0x82b42900) 
                    revert(0x1c, 0x04)
                }
            }
        }
    }
    
    function _checkRolesOrOwner(uint256 roles) internal view virtual {
        assembly {
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, caller())
            if iszero(and(sload(keccak256(0x0c, 0x20)), roles)) {
                if iszero(eq(caller(), sload(not(_ROLE_SLOT_SEED)))) {
                    mstore(0x00, 0x82b42900) 
                    revert(0x1c, 0x04)
                }
            }
        }
    }

    function _rolesFromOrdinals(uint8[] memory ordinals) internal pure returns (uint256 roles) {
        assembly {
            for { let i := shl(5, mload(ordinals)) } i { i := sub(i, 0x20) } {
                roles := or(shl(mload(add(ordinals, i)), 1), roles)
            }
        }
    }
    
    function _ordinalsFromRoles(uint256 roles) internal pure returns (uint8[] memory ordinals) {
        assembly {
            
            ordinals := mload(0x40)
            let ptr := add(ordinals, 0x20)
            let o := 0
            
            for { let t := roles } 1 {} {
                mstore(ptr, o)
                
                ptr := add(ptr, shl(5, and(t, 1)))
                o := add(o, 1)
                t := shr(o, roles)
                if iszero(t) { break }
            }
            
            mstore(ordinals, shr(5, sub(ptr, add(ordinals, 0x20))))
            mstore(0x40, ptr)
        }
    }
    
    function rolesOf(address user) public view virtual returns (uint256 roles) {
        
        assembly {
            
            mstore(0x0c, _ROLE_SLOT_SEED)
            mstore(0x00, user)
            
            roles := sload(keccak256(0x0c, 0x20))
        }
    }
    
    function hasAnyRole(address user, uint256 roles) public view virtual returns (bool) {
        return rolesOf(user) & roles != 0;
    }
    
    modifier onlyRoles(uint256 roles) virtual {
        _checkRoles(roles);
        _;
    }
    
    modifier onlyOwnerOrRoles(uint256 roles) virtual {
        _checkOwnerOrRoles(roles);
        _;
    }
    
    modifier onlyRolesOrOwner(uint256 roles) virtual {
        _checkRolesOrOwner(roles);
        _;
    }
    
    uint256 internal constant _ROLE_0 = 1 << 0;
    uint256 internal constant _ROLE_1 = 1 << 1;
    uint256 internal constant _ROLE_2 = 1 << 2;
    uint256 internal constant _ROLE_3 = 1 << 3;
    uint256 internal constant _ROLE_4 = 1 << 4;
    uint256 internal constant _ROLE_5 = 1 << 5;
    uint256 internal constant _ROLE_6 = 1 << 6;
    uint256 internal constant _ROLE_7 = 1 << 7;
    uint256 internal constant _ROLE_8 = 1 << 8;
    uint256 internal constant _ROLE_9 = 1 << 9;
    uint256 internal constant _ROLE_10 = 1 << 10;
    uint256 internal constant _ROLE_11 = 1 << 11;
    uint256 internal constant _ROLE_12 = 1 << 12;
    uint256 internal constant _ROLE_13 = 1 << 13;
    uint256 internal constant _ROLE_14 = 1 << 14;
    uint256 internal constant _ROLE_15 = 1 << 15;
    uint256 internal constant _ROLE_16 = 1 << 16;
    uint256 internal constant _ROLE_17 = 1 << 17;
    uint256 internal constant _ROLE_18 = 1 << 18;
    uint256 internal constant _ROLE_19 = 1 << 19;
    uint256 internal constant _ROLE_20 = 1 << 20;
    uint256 internal constant _ROLE_21 = 1 << 21;
    uint256 internal constant _ROLE_22 = 1 << 22;
    uint256 internal constant _ROLE_23 = 1 << 23;
    uint256 internal constant _ROLE_24 = 1 << 24;
    uint256 internal constant _ROLE_25 = 1 << 25;
    uint256 internal constant _ROLE_26 = 1 << 26;
    uint256 internal constant _ROLE_27 = 1 << 27;
    uint256 internal constant _ROLE_28 = 1 << 28;
    uint256 internal constant _ROLE_29 = 1 << 29;
    uint256 internal constant _ROLE_30 = 1 << 30;
    uint256 internal constant _ROLE_31 = 1 << 31;
    uint256 internal constant _ROLE_32 = 1 << 32;
    uint256 internal constant _ROLE_33 = 1 << 33;
    uint256 internal constant _ROLE_34 = 1 << 34;
    uint256 internal constant _ROLE_35 = 1 << 35;
    uint256 internal constant _ROLE_36 = 1 << 36;
    uint256 internal constant _ROLE_37 = 1 << 37;
    uint256 internal constant _ROLE_38 = 1 << 38;
    uint256 internal constant _ROLE_39 = 1 << 39;
    uint256 internal constant _ROLE_40 = 1 << 40;
    uint256 internal constant _ROLE_41 = 1 << 41;
    uint256 internal constant _ROLE_42 = 1 << 42;
    uint256 internal constant _ROLE_43 = 1 << 43;
    uint256 internal constant _ROLE_44 = 1 << 44;
    uint256 internal constant _ROLE_45 = 1 << 45;
    uint256 internal constant _ROLE_46 = 1 << 46;
    uint256 internal constant _ROLE_47 = 1 << 47;
    uint256 internal constant _ROLE_48 = 1 << 48;
    uint256 internal constant _ROLE_49 = 1 << 49;
    uint256 internal constant _ROLE_50 = 1 << 50;
    uint256 internal constant _ROLE_51 = 1 << 51;
    uint256 internal constant _ROLE_52 = 1 << 52;
    uint256 internal constant _ROLE_53 = 1 << 53;
    uint256 internal constant _ROLE_54 = 1 << 54;
    uint256 internal constant _ROLE_55 = 1 << 55;
    uint256 internal constant _ROLE_56 = 1 << 56;
    uint256 internal constant _ROLE_57 = 1 << 57;
    uint256 internal constant _ROLE_58 = 1 << 58;
    uint256 internal constant _ROLE_59 = 1 << 59;
    uint256 internal constant _ROLE_60 = 1 << 60;
    uint256 internal constant _ROLE_61 = 1 << 61;
    uint256 internal constant _ROLE_62 = 1 << 62;
    uint256 internal constant _ROLE_63 = 1 << 63;
    uint256 internal constant _ROLE_64 = 1 << 64;
    uint256 internal constant _ROLE_65 = 1 << 65;
    uint256 internal constant _ROLE_66 = 1 << 66;
    uint256 internal constant _ROLE_67 = 1 << 67;
    uint256 internal constant _ROLE_68 = 1 << 68;
    uint256 internal constant _ROLE_69 = 1 << 69;
    uint256 internal constant _ROLE_70 = 1 << 70;
    uint256 internal constant _ROLE_71 = 1 << 71;
    uint256 internal constant _ROLE_72 = 1 << 72;
    uint256 internal constant _ROLE_73 = 1 << 73;
    uint256 internal constant _ROLE_74 = 1 << 74;
    uint256 internal constant _ROLE_75 = 1 << 75;
    uint256 internal constant _ROLE_76 = 1 << 76;
    uint256 internal constant _ROLE_77 = 1 << 77;
    uint256 internal constant _ROLE_78 = 1 << 78;
    uint256 internal constant _ROLE_79 = 1 << 79;
    uint256 internal constant _ROLE_80 = 1 << 80;
    uint256 internal constant _ROLE_81 = 1 << 81;
    uint256 internal constant _ROLE_82 = 1 << 82;
    uint256 internal constant _ROLE_83 = 1 << 83;
    uint256 internal constant _ROLE_84 = 1 << 84;
    uint256 internal constant _ROLE_85 = 1 << 85;
    uint256 internal constant _ROLE_86 = 1 << 86;
    uint256 internal constant _ROLE_87 = 1 << 87;
    uint256 internal constant _ROLE_88 = 1 << 88;
    uint256 internal constant _ROLE_89 = 1 << 89;
    uint256 internal constant _ROLE_90 = 1 << 90;
    uint256 internal constant _ROLE_91 = 1 << 91;
    uint256 internal constant _ROLE_92 = 1 << 92;
    uint256 internal constant _ROLE_93 = 1 << 93;
    uint256 internal constant _ROLE_94 = 1 << 94;
    uint256 internal constant _ROLE_95 = 1 << 95;
    uint256 internal constant _ROLE_96 = 1 << 96;
    uint256 internal constant _ROLE_97 = 1 << 97;
    uint256 internal constant _ROLE_98 = 1 << 98;
    uint256 internal constant _ROLE_99 = 1 << 99;
    uint256 internal constant _ROLE_100 = 1 << 100;
    uint256 internal constant _ROLE_101 = 1 << 101;
    uint256 internal constant _ROLE_102 = 1 << 102;
    uint256 internal constant _ROLE_103 = 1 << 103;
    uint256 internal constant _ROLE_104 = 1 << 104;
    uint256 internal constant _ROLE_105 = 1 << 105;
    uint256 internal constant _ROLE_106 = 1 << 106;
    uint256 internal constant _ROLE_107 = 1 << 107;
    uint256 internal constant _ROLE_108 = 1 << 108;
    uint256 internal constant _ROLE_109 = 1 << 109;
    uint256 internal constant _ROLE_110 = 1 << 110;
    uint256 internal constant _ROLE_111 = 1 << 111;
    uint256 internal constant _ROLE_112 = 1 << 112;
    uint256 internal constant _ROLE_113 = 1 << 113;
    uint256 internal constant _ROLE_114 = 1 << 114;
    uint256 internal constant _ROLE_115 = 1 << 115;
    uint256 internal constant _ROLE_116 = 1 << 116;
    uint256 internal constant _ROLE_117 = 1 << 117;
    uint256 internal constant _ROLE_118 = 1 << 118;
    uint256 internal constant _ROLE_119 = 1 << 119;
    uint256 internal constant _ROLE_120 = 1 << 120;
    uint256 internal constant _ROLE_121 = 1 << 121;
    uint256 internal constant _ROLE_122 = 1 << 122;
    uint256 internal constant _ROLE_123 = 1 << 123;
    uint256 internal constant _ROLE_124 = 1 << 124;
    uint256 internal constant _ROLE_125 = 1 << 125;
    uint256 internal constant _ROLE_126 = 1 << 126;
    uint256 internal constant _ROLE_127 = 1 << 127;
    uint256 internal constant _ROLE_128 = 1 << 128;
    uint256 internal constant _ROLE_129 = 1 << 129;
    uint256 internal constant _ROLE_130 = 1 << 130;
    uint256 internal constant _ROLE_131 = 1 << 131;
    uint256 internal constant _ROLE_132 = 1 << 132;
    uint256 internal constant _ROLE_133 = 1 << 133;
    uint256 internal constant _ROLE_134 = 1 << 134;
    uint256 internal constant _ROLE_135 = 1 << 135;
    uint256 internal constant _ROLE_136 = 1 << 136;
    uint256 internal constant _ROLE_137 = 1 << 137;
    uint256 internal constant _ROLE_138 = 1 << 138;
    uint256 internal constant _ROLE_139 = 1 << 139;
    uint256 internal constant _ROLE_140 = 1 << 140;
    uint256 internal constant _ROLE_141 = 1 << 141;
    uint256 internal constant _ROLE_142 = 1 << 142;
    uint256 internal constant _ROLE_143 = 1 << 143;
    uint256 internal constant _ROLE_144 = 1 << 144;
    uint256 internal constant _ROLE_145 = 1 << 145;
    uint256 internal constant _ROLE_146 = 1 << 146;
    uint256 internal constant _ROLE_147 = 1 << 147;
    uint256 internal constant _ROLE_148 = 1 << 148;
    uint256 internal constant _ROLE_149 = 1 << 149;
    uint256 internal constant _ROLE_150 = 1 << 150;
    uint256 internal constant _ROLE_151 = 1 << 151;
    uint256 internal constant _ROLE_152 = 1 << 152;
    uint256 internal constant _ROLE_153 = 1 << 153;
    uint256 internal constant _ROLE_154 = 1 << 154;
    uint256 internal constant _ROLE_155 = 1 << 155;
    uint256 internal constant _ROLE_156 = 1 << 156;
    uint256 internal constant _ROLE_157 = 1 << 157;
    uint256 internal constant _ROLE_158 = 1 << 158;
    uint256 internal constant _ROLE_159 = 1 << 159;
    uint256 internal constant _ROLE_160 = 1 << 160;
    uint256 internal constant _ROLE_161 = 1 << 161;
    uint256 internal constant _ROLE_162 = 1 << 162;
    uint256 internal constant _ROLE_163 = 1 << 163;
    uint256 internal constant _ROLE_164 = 1 << 164;
    uint256 internal constant _ROLE_165 = 1 << 165;
    uint256 internal constant _ROLE_166 = 1 << 166;
    uint256 internal constant _ROLE_167 = 1 << 167;
    uint256 internal constant _ROLE_168 = 1 << 168;
    uint256 internal constant _ROLE_169 = 1 << 169;
    uint256 internal constant _ROLE_170 = 1 << 170;
    uint256 internal constant _ROLE_171 = 1 << 171;
    uint256 internal constant _ROLE_172 = 1 << 172;
    uint256 internal constant _ROLE_173 = 1 << 173;
    uint256 internal constant _ROLE_174 = 1 << 174;
    uint256 internal constant _ROLE_175 = 1 << 175;
    uint256 internal constant _ROLE_176 = 1 << 176;
    uint256 internal constant _ROLE_177 = 1 << 177;
    uint256 internal constant _ROLE_178 = 1 << 178;
    uint256 internal constant _ROLE_179 = 1 << 179;
    uint256 internal constant _ROLE_180 = 1 << 180;
    uint256 internal constant _ROLE_181 = 1 << 181;
    uint256 internal constant _ROLE_182 = 1 << 182;
    uint256 internal constant _ROLE_183 = 1 << 183;
    uint256 internal constant _ROLE_184 = 1 << 184;
    uint256 internal constant _ROLE_185 = 1 << 185;
    uint256 internal constant _ROLE_186 = 1 << 186;
    uint256 internal constant _ROLE_187 = 1 << 187;
    uint256 internal constant _ROLE_188 = 1 << 188;
    uint256 internal constant _ROLE_189 = 1 << 189;
    uint256 internal constant _ROLE_190 = 1 << 190;
    uint256 internal constant _ROLE_191 = 1 << 191;
    uint256 internal constant _ROLE_192 = 1 << 192;
    uint256 internal constant _ROLE_193 = 1 << 193;
    uint256 internal constant _ROLE_194 = 1 << 194;
    uint256 internal constant _ROLE_195 = 1 << 195;
    uint256 internal constant _ROLE_196 = 1 << 196;
    uint256 internal constant _ROLE_197 = 1 << 197;
    uint256 internal constant _ROLE_198 = 1 << 198;
    uint256 internal constant _ROLE_199 = 1 << 199;
    uint256 internal constant _ROLE_200 = 1 << 200;
    uint256 internal constant _ROLE_201 = 1 << 201;
    uint256 internal constant _ROLE_202 = 1 << 202;
    uint256 internal constant _ROLE_203 = 1 << 203;
    uint256 internal constant _ROLE_204 = 1 << 204;
    uint256 internal constant _ROLE_205 = 1 << 205;
    uint256 internal constant _ROLE_206 = 1 << 206;
    uint256 internal constant _ROLE_207 = 1 << 207;
    uint256 internal constant _ROLE_208 = 1 << 208;
    uint256 internal constant _ROLE_209 = 1 << 209;
    uint256 internal constant _ROLE_210 = 1 << 210;
    uint256 internal constant _ROLE_211 = 1 << 211;
    uint256 internal constant _ROLE_212 = 1 << 212;
    uint256 internal constant _ROLE_213 = 1 << 213;
    uint256 internal constant _ROLE_214 = 1 << 214;
    uint256 internal constant _ROLE_215 = 1 << 215;
    uint256 internal constant _ROLE_216 = 1 << 216;
    uint256 internal constant _ROLE_217 = 1 << 217;
    uint256 internal constant _ROLE_218 = 1 << 218;
    uint256 internal constant _ROLE_219 = 1 << 219;
    uint256 internal constant _ROLE_220 = 1 << 220;
    uint256 internal constant _ROLE_221 = 1 << 221;
    uint256 internal constant _ROLE_222 = 1 << 222;
    uint256 internal constant _ROLE_223 = 1 << 223;
    uint256 internal constant _ROLE_224 = 1 << 224;
    uint256 internal constant _ROLE_225 = 1 << 225;
    uint256 internal constant _ROLE_226 = 1 << 226;
    uint256 internal constant _ROLE_227 = 1 << 227;
    uint256 internal constant _ROLE_228 = 1 << 228;
    uint256 internal constant _ROLE_229 = 1 << 229;
    uint256 internal constant _ROLE_230 = 1 << 230;
    uint256 internal constant _ROLE_231 = 1 << 231;
    uint256 internal constant _ROLE_232 = 1 << 232;
    uint256 internal constant _ROLE_233 = 1 << 233;
    uint256 internal constant _ROLE_234 = 1 << 234;
    uint256 internal constant _ROLE_235 = 1 << 235;
    uint256 internal constant _ROLE_236 = 1 << 236;
    uint256 internal constant _ROLE_237 = 1 << 237;
    uint256 internal constant _ROLE_238 = 1 << 238;
    uint256 internal constant _ROLE_239 = 1 << 239;
    uint256 internal constant _ROLE_240 = 1 << 240;
    uint256 internal constant _ROLE_241 = 1 << 241;
    uint256 internal constant _ROLE_242 = 1 << 242;
    uint256 internal constant _ROLE_243 = 1 << 243;
    uint256 internal constant _ROLE_244 = 1 << 244;
    uint256 internal constant _ROLE_245 = 1 << 245;
    uint256 internal constant _ROLE_246 = 1 << 246;
    uint256 internal constant _ROLE_247 = 1 << 247;
    uint256 internal constant _ROLE_248 = 1 << 248;
    uint256 internal constant _ROLE_249 = 1 << 249;
    uint256 internal constant _ROLE_250 = 1 << 250;
    uint256 internal constant _ROLE_251 = 1 << 251;
    uint256 internal constant _ROLE_252 = 1 << 252;
    uint256 internal constant _ROLE_253 = 1 << 253;
    uint256 internal constant _ROLE_254 = 1 << 254;
    uint256 internal constant _ROLE_255 = 1 << 255;
}

{
  "optimizer": {
    "enabled": false,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyInitialized","type":"error"},{"inputs":[],"name":"AlreadyRevealed","type":"error"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"CantExceedMaxWallet","type":"error"},{"inputs":[],"name":"CantRevealYet","type":"error"},{"inputs":[],"name":"InsufficientAllowance","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"LinkMirrorContractFailed","type":"error"},{"inputs":[],"name":"MaxBalanceLimitReached","type":"error"},{"inputs":[],"name":"NewOwnerIsZeroAddress","type":"error"},{"inputs":[],"name":"NoHandoverRequest","type":"error"},{"inputs":[{"internalType":"address","name":"have","type":"address"},{"internalType":"address","name":"want","type":"address"}],"name":"OnlyCoordinatorCanFulfill","type":"error"},{"inputs":[],"name":"SenderNotMirror","type":"error"},{"inputs":[],"name":"TokenDoesNotExist","type":"error"},{"inputs":[],"name":"TotalSupplyOverflow","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"Unauthorized","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":"amount","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"target","type":"address"},{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"SkipNFTSet","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":"amount","type":"uint256"}],"name":"Transfer","type":"event"},{"stateMutability":"payable","type":"fallback"},{"inputs":[],"name":"ADMIN_ROLE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ClaimVested","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"DEVWALLET","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Hermes","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"KEYHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"LPAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Lottery","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"ReadVested","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"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":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"canReveal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"freeReveal","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"roles","type":"uint256"}],"name":"hasAnyRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"hasClaim","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"adr","type":"address"}],"name":"hasFreeReveal","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"mirror","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"lottery","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"maxWallet","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mirrorERC721","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"result","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"requestId","type":"uint256"},{"internalType":"uint256[]","name":"randomWords","type":"uint256[]"}],"name":"rawFulfillRandomWords","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"rolesOf","outputs":[{"internalType":"uint256","name":"roles","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"can","type":"bool"}],"name":"setCanReveal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"keyHash","type":"bytes32"}],"name":"setKeyHash","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"lp","type":"address"}],"name":"setLPAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setLotteryHermesPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setLotteryPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"status","type":"bool"}],"name":"setMaxWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"vrfid","type":"uint64"}],"name":"setVrfId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"target","type":"address"},{"internalType":"bool","name":"status","type":"bool"}],"name":"setWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"result","type":"string"}],"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":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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