Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

import "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
import "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

/**
 * Interfaces SuperFarm's Super1155 contract
 * See example contracts: https://etherscan.io/address/0x71B11Ac923C967CD5998F23F6dae0d779A6ac8Af#code,
 * https://etherscan.io/address/0xc7b9D8483FD01C379a4141B2Ee7c39442172b259#code
 *
 * @notice To stake tokens an account must setApprovalForAll() using the address of this contract in the above contracts
 */
interface Super1155 {
  function safeBatchTransferFrom(
    address _from,
    address _to,
    uint256[] memory _ids,
    uint256[] memory _amounts,
    bytes memory _data
  ) external;

  function safeTransferFrom(
    address _from,
    address _to,
    uint256 _id,
    uint256 _amount,
    bytes calldata _data
  ) external;

  function balanceOf(address _owner, uint256 _id)
    external
    view
    returns (uint256);

  function isApprovedForAll(address _owner, address _operator)
    external
    view
    returns (bool);
}

/**
 * @title A staking contract for Super1155 tokens.
 * @author DegenDeveloper.eth
 *
 * April 25, 2022
 *
 * This contract allows users to stake their tokens to earn emission tokens.
 *
 * This contract is only capable of transferring tokens to their original stakers.
 *
 * Accounts always have the ability to unstake their tokens no matter the contract state.
 *
 * The contract owner has the following permissions:
 *
 * - Open/close staking; enabling/disabling the addition of new stakes
 * - Blacklist an account; disabling the addition of new stakes for a specific address
 * - Pause emissions; stops the counting of emission tokens
 * - Set new emission rates; sets a new rate for earning emission tokens
 *    - if emissions are paused this unpauses them
 *    - historic emission rates (emRates) are stored in the contract to accurately calculate emissions
 *
 * --------( In case of security breach )---------
 *
 * Accounts will always have the ability to unstake their tokens, no matter the state of the contract; however,
 *
 * If there is a security breach or the team wishes to terminate the grill, they have the ability to permanently close staking,
 * sending back all tokens to their original stakers.
 *
 * The contract owner must call toggleBailout() before they force unstake any tokens.
 *
 * ToggleBailout() is only callable once
 *
 * Once toggleBailout() has been called, bailoutAllStakes() becomes callable. This function will unstake all tokens and send them back to their original stakers.
 * If there are gas limits sending back all tokens in a single transaction, the function bailoutSingleStake(_tokenId) also becomes callable,
 * allowing each tokenId to be unstaked manually
 */
contract Grill is Ownable, ERC1155Holder {
  /// used for variables that start at 0 and only increment/decrement by 1 at a time
  using Counters for Counters.Counter;

  /// the contract instance for the tokens being staked
  Super1155 private immutable Parent;

  bool private STAKING_ACTIVE;
  bool private BAILED_OUT;

  /// the max number of tokens to stake/unstake in a single txn
  uint256 private constant MAX_TXN = 20;

  /// the max number of seconds possible, used for pausing emissions
  uint256 private constant MAX_INT = 2**256 - 1;

  /// a mapping from each tokenId to its stake details
  mapping(uint256 => Stake) private stakes;

  /// a mapping from each address to an indexed mapping of the tokenIds they have staked
  mapping(address => mapping(uint256 => uint256)) private addrStakesIds;

  /// a mapping from each address to a counter for tokens currently staked
  mapping(address => Counters.Counter) private addrStakesCount;

  /// a mapping from each address to their ability to add new stakes
  mapping(address => bool) private blacklist;

  /// a counter for the number of times the emission rate changes
  Counters.Counter private emChanges;

  /// a mapping from each emChange to its associated emission details
  mapping(uint256 => Emission) private emissions;

  /// a mapping from each address to their emission claims earned from their removed stakes
  mapping(address => uint256) private unstakedClaims;

  /// a counter for the number of active stakes
  Counters.Counter private allStakesCount;

  /// an indexed mapping for all tokenIds staked currently
  mapping(uint256 => uint256) private allStakes;

  /**
   * This struct stores information about staked tokens. They are stored
   * in the `stakes` mapping by tokenId
   * @param status If tokenId is staked or not
   * @param staker The staker of tokenId
   * @param timestamp The time tokenId was staked
   */
  struct Stake {
    bool status;
    address staker;
    uint256 timestamp;
  }

  /**
   * This struct stores information about emissions. They are stored in
   * the 'emissions' mapping by emChange
   * @param rate The number of seconds to earn 1 token
   * @param timestamp The time the emission rate was set
   */
  struct Emission {
    uint256 rate;
    uint256 timestamp;
  }

  /// ============ CONSTRUCTOR ============ ///

  /**
   * Initializes the parent contract instance, the initial emission rate, and timestamps the deploy
   * @param _parentAddr The contract address to allow staking from
   */
  constructor(address _parentAddr) {
    Parent = Super1155(_parentAddr);
    STAKING_ACTIVE = true;
    BAILED_OUT = false;
    uint256 secondsIn45Days = 3600 * 24 * 45;
    emissions[emChanges.current()] = Emission(secondsIn45Days, block.timestamp);
  }

  /// ============ OWNER FUNCTIONS ============ ///

  /**
   * For allowing/unallowing the addition of new stakes
   * @notice This function is disabled once toggleBailout() is called
   */
  function toggleStaking() external onlyOwner {
    require(!BAILED_OUT, "GRILL: contract has been terminated");
    STAKING_ACTIVE = !STAKING_ACTIVE;
  }

  /**
   * For allowing/unallowing an address to add new stakes
   * @notice A staker is always able to remove their stakes regardless of contract state
   * @param _addr The address to set blacklist status for
   * @param _status The status to set for _addr
   */
  function blacklistAddr(address _addr, bool _status) external onlyOwner {
    blacklist[_addr] = _status;
  }

  /**
   * Stops the counting of emission tokens
   * @notice No tokens can be earned with an emission rate this long
   * @notice To continue emissions counting, the owner must set a new emission rate
   */
  function pauseEmissions() external onlyOwner {
    _setEmissionRate(MAX_INT);
  }

  /**
   * Sets new emission rate
   * @param _seconds The number of seconds a token must be staked for to earn 1 emission token
   */
  function setEmissionRate(uint256 _seconds) external onlyOwner {
    require(!BAILED_OUT, "GRILL: cannot change emission rate after bailout");
    _setEmissionRate(_seconds);
  }

  /**
   * Pauses staking/emissions counting permanently
   * @notice This function is only callable once and all state changes are final
   * @notice It must be called before bailoutAllStakes() or bailoutSingleStake()
   */
  function toggleBailout() external onlyOwner {
    require(!BAILED_OUT, "GRILL: bailout already called");
    STAKING_ACTIVE = false;
    BAILED_OUT = true;
    _setEmissionRate(MAX_INT);
  }

  /**
   * Sends back all tokens to their original stakers
   * @notice toggleBailout() must be called
   */
  function bailoutAllStakes() external onlyOwner {
    require(BAILED_OUT, "GRILL: toggleBailout() must be called first");

    /// @dev copies current number of stakes before bailout ///
    uint256 _totalCount = allStakesCount.current();
    for (uint256 i = 1; i <= _totalCount; ++i) {
      /// @dev gets token and staker for last token staked ///
      uint256 _lastTokenId = allStakes[allStakesCount.current()];
      address _staker = stakes[_lastTokenId].staker;

      /// @dev transferrs _lastTokenId from the contract to associated _staker ///
      Parent.safeTransferFrom(address(this), _staker, _lastTokenId, 1, "0x0");

      /// @dev sets state changes ///
      uint256[] memory _singleArray = _makeOnesArray(1);
      _singleArray[0] = _lastTokenId; // _removeStakes() requires an array of tokenIds
      _removeStakes(_staker, _singleArray);
    }
  }

  /**
   * Sends back _tokenId to its original staker
   * @notice toggleBailout() must be called
   * @notice This function is here in case bailoutAllStakes() has gas limitations
   */
  function bailoutSingleStake(uint256 _tokenId) external onlyOwner {
    require(BAILED_OUT, "GRILL: toggleBailout() must be called first");

    Parent.safeTransferFrom(
      address(this),
      stakes[_tokenId].staker,
      _tokenId,
      1,
      "0x0"
    );

    /// @dev sets state changes ///
    uint256[] memory _singleArray = _makeOnesArray(1);
    _singleArray[0] = _tokenId;
    _removeStakes(stakes[_tokenId].staker, _singleArray);
  }

  /// ============ PUBLIC FUNCTIONS ============ ///

  /**
   * Transfer tokens from caller to contract and begins emissions counting
   * @param _tokenIds The tokenIds to stake
   * @param _amounts The amount of each tokenId to stake
   * @notice _amounts must have a value of 1 at each index
   */
  function addStakes(uint256[] memory _tokenIds, uint256[] memory _amounts)
    external
  {
    require(STAKING_ACTIVE, "GRILL: staking is not active");
    require(!blacklist[msg.sender], "GRILL: caller is blacklisted");
    require(_tokenIds.length > 0, "GRILL: must stake more than 0 tokens");
    require(
      _tokenIds.length <= MAX_TXN,
      "GRILL: must stake less than MAX_TXN tokens per txn"
    );
    require(
      _isOwnerOfBatch(msg.sender, _tokenIds, _amounts),
      "GRILL: caller does not own these tokens"
    );
    require(
      Parent.isApprovedForAll(msg.sender, address(this)),
      "GRILL: contract is not an approved operator for caller's tokens"
    );

    /// @dev transfers token batch from caller to contract
    Parent.safeBatchTransferFrom(
      msg.sender,
      address(this),
      _tokenIds,
      _amounts,
      "0x0"
    );

    /// @dev sets contract state
    _addStakes(msg.sender, _tokenIds);
  }

  /**
   * Transfer tokens from contract to caller and records emissions in unStakedClaims
   * @param _tokenIds The tokenIds to unstake
   * @param _amounts The amount of each tokenId to unstake
   * @notice _amounts must have a value of 1 at each index
   */
  function removeStakes(uint256[] memory _tokenIds, uint256[] memory _amounts)
    external
  {
    require(_tokenIds.length > 0, "GRILL: must unstake more than 0 tokens");
    require(
      _tokenIds.length <= MAX_TXN,
      "GRILL: cannot stake more than MAX_TXN tokens in a single txn"
    );
    require(_tokenIds.length == _amounts.length, "GRILL: arrays mismatch");
    require(
      _isStakerOfBatch(msg.sender, _tokenIds, _amounts),
      "GRILL: caller was not the staker of these tokens"
    );
    require(
      _tokenIds.length <= addrStakesCount[msg.sender].current(),
      "GRILL: caller is unstaking too many tokens"
    );

    /// @dev transfers token batch from contract to caller ///
    Parent.safeBatchTransferFrom(
      address(this),
      msg.sender,
      _tokenIds,
      _amounts,
      "0x0"
    );

    /// @dev sets contract state ///
    _removeStakes(msg.sender, _tokenIds);
  }

  /// ============ PRIVATE/HELPER FUNCTIONS ============ ///

  /**
   * Verifies if an address can stake a batch of tokens
   * @param _operator The address trying to stake
   * @param _tokenIds The tokenIds _operator is trying to stake
   * @param _amounts The amount of each tokenId caller is trying to stake
   * @notice Each element in _amounts must be 1
   * @return _b If _operator can unstake _tokenIds
   */
  function _isOwnerOfBatch(
    address _operator,
    uint256[] memory _tokenIds,
    uint256[] memory _amounts
  ) private view returns (bool _b) {
    _b = true;
    for (uint256 i = 0; i < _tokenIds.length; ++i) {
      if (parentBalance(_operator, _tokenIds[i]) == 0 || _amounts[i] != 1) {
        _b = false;
        break;
      }
    }
  }

  /**
   * Verifies if an address can unstake a batch of tokens
   * @param _operator The address trying to unstake
   * @param _tokenIds The tokenIds _operator is trying to unstake
   * @param _amounts The amount of each tokenId caller is trying to unstake
   * @notice Each element in _amounts must be 1
   * @return _b If _operator can unstake _tokenIds
   */
  function _isStakerOfBatch(
    address _operator,
    uint256[] memory _tokenIds,
    uint256[] memory _amounts
  ) private view returns (bool _b) {
    _b = true;
    for (uint256 i = 0; i < _tokenIds.length; ++i) {
      if (stakes[_tokenIds[i]].staker != _operator || _amounts[i] != 1) {
        _b = false;
        break;
      }
    }
  }

  /**
   * Helper function for setting contract state when tokens are staked
   * @param _staker The address staking tokens
   * @param _tokenIds The tokenIds being staked
   */
  function _addStakes(address _staker, uint256[] memory _tokenIds) private {
    for (uint256 i = 0; i < _tokenIds.length; ++i) {
      require(!stakes[_tokenIds[i]].status, "GRILL: token already staked");

      /// increment counters
      addrStakesCount[_staker].increment();
      allStakesCount.increment();

      /// set mappings
      addrStakesIds[_staker][addrStakesCount[_staker].current()] = _tokenIds[i];
      allStakes[allStakesCount.current()] = _tokenIds[i];
      stakes[_tokenIds[i]] = Stake(true, _staker, block.timestamp);
    }
  }

  /**
   * Helper function for setting contract state when tokens are unstaked
   * @param _staker The address unstaking tokens
   * @param _tokenIds The tokenIds being unstaked
   */
  function _removeStakes(address _staker, uint256[] memory _tokenIds) private {
    for (uint256 i = 0; i < _tokenIds.length; ++i) {
      require(
        stakes[_tokenIds[i]].status,
        "GRILL: token is not currently staked"
      );

      /// count rewards earned
      uint256 _tokenId = _tokenIds[i];
      unstakedClaims[_staker] += _countEmissions(_tokenId);

      /// @dev resets Stake object in `stakes` mapping ///
      delete stakes[_tokenId];

      /// last index of mappings
      uint256 _t = addrStakesCount[_staker].current();
      uint256 _t1 = allStakesCount.current();

      /// @dev finds _tokenId in mappings, swaps it with last index ///
      for (uint256 j = 1; j < _t; ++j) {
        if (addrStakesIds[_staker][j] == _tokenId) {
          addrStakesIds[_staker][j] = addrStakesIds[_staker][_t];
        }
      }
      for (uint256 k = 1; k < _t1; ++k) {
        if (allStakes[k] == _tokenId) {
          allStakes[k] = allStakes[_t1];
        }
      }

      /// @dev resets last item in mappings
      delete addrStakesIds[_staker][_t];
      delete allStakes[_t1];

      /// decrement counters, avoiding decrement overflow
      if (_t != 0) {
        addrStakesCount[_staker].decrement();
      }
      if (_t1 != 0) {
        allStakesCount.decrement();
      }
    }
  }

  /**
   * Helper function for setting contract state when emission changes occur
   * @param _seconds The number of seconds a token must be staked for to earn 1 emission token
   * @notice The emission rate cannot be 0 seconds
   */
  function _setEmissionRate(uint256 _seconds) private {
    require(_seconds > 0, "GRILL: emission rate cannot be 0");
    emChanges.increment();
    emissions[emChanges.current()] = Emission(_seconds, block.timestamp);
  }

  /**
   * Helper function to count number of emission tokens _tokenId has earned
   * @param _tokenId The tokenId to check
   * @notice A token must be staked to count emissions
   */
  function _countEmissions(uint256 _tokenId) private view returns (uint256 _c) {
    require(stakes[_tokenId].status, "GRILL: token is not currently staked");

    /// @dev finds the first emission rate _tokenId was staked for ///
    uint256 minT;
    uint256 timeStake = stakes[_tokenId].timestamp;
    for (uint256 i = 1; i <= emChanges.current(); ++i) {
      if (emissions[i].timestamp < timeStake) {
        minT += 1;
      }
    }
    /// @dev counts all emissions earned starting from minT -> now
    for (uint256 i = minT; i <= emChanges.current(); ++i) {
      uint256 tSmall = emissions[i].timestamp;
      uint256 tBig = emissions[i + 1].timestamp;
      if (i == minT) {
        tSmall = timeStake;
      }
      if (i == emChanges.current()) {
        tBig = block.timestamp;
      }
      _c += (tBig - tSmall) / emissions[i].rate;
    }
  }

  /**
   * Helper function for creating an array of all 1's
   * @param _n The size of the array
   * @return _ones An array of size _n with a value of 1 at each index
   */
  function _makeOnesArray(uint256 _n)
    private
    pure
    returns (uint256[] memory _ones)
  {
    _ones = new uint256[](_n);
    for (uint256 i = 0; i < _n; i++) {
      _ones[i] = 1;
    }
    return _ones;
  }

  /// ============ READ-ONLY FUNCTIONS ============ ///

  /**
   * Get the balance for a specifc tokenId in parent contract
   * @param _operator The address to lookup
   * @param _tokenId The token id to check balance of
   * @return _c The _tokenId balance of _operator
   */
  function parentBalance(address _operator, uint256 _tokenId)
    public
    view
    returns (uint256 _c)
  {
    _c = Parent.balanceOf(_operator, _tokenId);
  }

  /**
   * @return _b If the contract is allowing new stakes to be added
   */
  function isStakingActive() external view returns (bool _b) {
    _b = STAKING_ACTIVE;
  }

  /**
   * @return _b If the contract has been bailed out
   */
  function isBailedOut() external view returns (bool _b) {
    _b = BAILED_OUT;
  }

  /**
   * @param _addr The address to lookup
   * @return _b Blacklist status
   */
  function isBlacklisted(address _addr) external view returns (bool _b) {
    _b = blacklist[_addr];
  }

  /**
   * @return _changes The current number of emission changes to date
   */
  function getEmissionChanges() external view returns (uint256 _changes) {
    _changes = emChanges.current();
  }

  /**
   * Get details for an emission change
   * @param _change The change number to lookup
   * @return _emission The emission object for emChange _change
   * @notice A _change must have occured to view it
   */
  function getEmission(uint256 _change)
    external
    view
    returns (Emission memory _emission)
  {
    require(_change <= emChanges.current(), "GRILL: invalid index to lookup");
    _emission = emissions[_change];
  }

  /**
   * @return _allStakingIds Array of tokenIds currently being staked
   */
  function getAllStakedIds()
    external
    view
    returns (uint256[] memory _allStakingIds)
  {
    _allStakingIds = new uint256[](allStakesCount.current());
    for (uint256 i = 0; i < _allStakingIds.length; ++i) {
      _allStakingIds[i] = allStakes[i + 1];
    }
  }

  /**
   * Get details for a staked token
   * @param _tokenId The tokenId to lookup
   * @return _stake The stake of _tokenId
   * @notice A _tokenId must currently be staked to view it
   */
  function getStake(uint256 _tokenId)
    external
    view
    returns (Stake memory _stake)
  {
    require(stakes[_tokenId].status, "GRILL: tokenId is not staked");
    _stake = stakes[_tokenId];
  }

  /**
   * @param _operator The address to lookup
   * @return _addrStakes Array of tokenIds currently staked by _operator
   */
  function getIdsOfAddr(address _operator)
    external
    view
    returns (uint256[] memory _addrStakes)
  {
    _addrStakes = new uint256[](addrStakesCount[_operator].current());
    for (uint256 i = 0; i < _addrStakes.length; ++i) {
      _addrStakes[i] = addrStakesIds[_operator][i + 1];
    }
  }

  /**
   * @param _operator The address to lookup
   * @return _claims The number of claims _operator has earned from their unstaked bulls
   */
  function getUnstakedClaims(address _operator) public view returns (uint256) {
    return unstakedClaims[_operator];
  }

  /**
   * @param _operator The address to lookup
   * @return _total The number of claims an address has earned from their current stakes
   */
  function getStakedClaims(address _operator)
    public
    view
    returns (uint256 _total)
  {
    for (uint256 i = 1; i <= addrStakesCount[_operator].current(); i++) {
      _total += _countEmissions(addrStakesIds[_operator][i]);
    }
  }

  /**
   * @param _operator The address to lookup
   * @return _total The number of emissions _operator has earned from all past and current stakes
   */
  function getTotalClaims(address _operator)
    external
    view
    returns (uint256 _total)
  {
    _total = unstakedClaims[_operator];
    _total += getStakedClaims(_operator);
  }
}

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

import "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Counters.sol";

/**
 * Interfaces Grill contracts
 */
interface GrillC {
  function getTotalClaims(address _operator) external view returns (uint256);
}

/**
 * @title An erc-1155 nft contract.
 * @author DegenDeveloper.eth
 *
 * March 29th, 2022
 *
 * This contract allows addresses to mint tokens earned from AstroGrill
 * and/or RickstroGrill staking.
 *
 * The contract owner has the following permissions:
 * - toggle minting.
 * - toggle burning.
 * - update the URI for tokens.
 * - mint tokens for marketing/giveaways without restriction
 */
contract Burger is ERC1155, Ownable {
  using Counters for Counters.Counter;

  /// contract instances
  GrillC public immutable AstroGrill;
  GrillC public immutable RickstroGrill;

  Counters.Counter private totalMinted;
  Counters.Counter private totalBurned;

  bool private CAN_MINT = false;
  bool private CAN_BURN = false;

  /// lookup identifiers
  bytes32 constant MINTS = keccak256("CLAIMS");
  bytes32 constant BURNS = keccak256("BURNS");

  /// mapping for the number of mints/burns of each address
  mapping(bytes32 => mapping(address => Counters.Counter)) private stats;

  /**
   * @param _aGrillAddr The address of the astro grill
   * @param _rGrillAddr The address of the rickstro grill
   */
  constructor(address _aGrillAddr, address _rGrillAddr)
    ERC1155("burger.io/{}.json")
  {
    AstroGrill = GrillC(_aGrillAddr);
    RickstroGrill = GrillC(_rGrillAddr);
  }

  /// ============ OWNER FUNCTIONS ============ ///

  /**
   * Sets the URI for the collection
   * @param _URI The new URI
   */
  function setURI(string memory _URI) public onlyOwner {
    _setURI(_URI);
  }

  function toggleMinting() external onlyOwner {
    CAN_MINT = !CAN_MINT;
  }

  function toggleBurning() external onlyOwner {
    CAN_BURN = !CAN_BURN;
  }

  /**
   * Allows contract owner to mint tokens for giveaways/etc.
   * @param _amount The number of tokens to mint
   * @param _addr The address to mint the tokens to
   */
  function ownerMint(uint256 _amount, address _addr) external onlyOwner {
    uint256[] memory _ids = new uint256[](_amount);
    uint256[] memory _amounts = new uint256[](_amount);

    for (uint256 i = 0; i < _amount; i++) {
      totalMinted.increment();
      _ids[i] = totalMinted.current();
      _amounts[i] = 1;
    }

    _mintBatch(_addr, _ids, _amounts, "0x0");
  }

  /// ============ PUBLIC FUNCTIONS ============ ///

  /**
   * Mint tokens to caller
   * @param _amount The number of tokens to mint
   */
  function mintPublic(uint256 _amount) external {
    require(CAN_MINT, "BURGER: minting is not active");
    require(_amount > 0, "BURGER: must claim more than 0 tokens");
    require(
      stats[MINTS][msg.sender].current() + _amount <=
        AstroGrill.getTotalClaims(msg.sender) +
          RickstroGrill.getTotalClaims(msg.sender),
      "BURGER: caller cannot claim this many tokens"
    );

    uint256[] memory _ids = new uint256[](_amount);
    uint256[] memory _amounts = new uint256[](_amount);

    for (uint256 i = 0; i < _amount; i++) {
      stats[MINTS][msg.sender].increment();
      totalMinted.increment();
      _ids[i] = totalMinted.current();
      _amounts[i] = 1;
    }

    _mintBatch(msg.sender, _ids, _amounts, "0x0");
  }

  /**
   * Burns callers tokens and records amount burned
   * @param _ids Array of token ids caller is trying to burn
   */
  function burnPublic(uint256[] memory _ids) external {
    require(CAN_BURN, "BURGER: burning is not active");
    require(_ids.length > 0, "BURGER: must burn more than 0 tokens");

    uint256[] memory _amounts = new uint256[](_ids.length);

    for (uint256 i = 0; i < _ids.length; i++) {
      require(
        balanceOf(msg.sender, _ids[i]) > 0,
        "BURGER: caller is not token owner"
      );
      _amounts[i] = 1;
      stats[BURNS][msg.sender].increment();
      totalBurned.increment();
    }
    _burnBatch(msg.sender, _ids, _amounts);
  }

  /// ============ READ-ONLY FUNCTIONS ============ ///

  /**
   * @return _b If minting tokens is currently allowed
   */
  function isMinting() external view returns (bool _b) {
    return CAN_MINT;
  }

  /**
   * @return _b If burning tokens is currently allowed
   */
  function isBurning() external view returns (bool _b) {
    return CAN_BURN;
  }

  /**
   * @return _supply The number of tokens in circulation
   */
  function totalSupply() external view returns (uint256 _supply) {
    _supply = totalMinted.current() - totalBurned.current();
  }

  /**
   * @return _mints The number of tokens minted
   */
  function totalMints() external view returns (uint256 _mints) {
    _mints = totalMinted.current();
  }

  /**
   * @return _burns The number of tokens burned
   */
  function totalBurns() external view returns (uint256 _burns) {
    _burns = totalBurned.current();
  }

  /**
   * @param _operator The address to lookup
   * @return _remaining The number of tokens _operator can mint
   */
  function tokenMintsLeft(address _operator)
    external
    view
    returns (uint256 _remaining)
  {
    _remaining =
      AstroGrill.getTotalClaims(_operator) +
      RickstroGrill.getTotalClaims(_operator) -
      stats[MINTS][_operator].current();
  }

  /**
   * @param _operator The address to lookup
   * @return _mints The number of tokens _operator has minted
   */
  function tokenMints(address _operator)
    external
    view
    returns (uint256 _mints)
  {
    _mints = stats[MINTS][_operator].current();
  }

  /**
   * @return _burns The number of tokens _operator has burned
   */
  function tokenBurns(address _operator)
    external
    view
    returns (uint256 _burns)
  {
    _burns = stats[BURNS][_operator].current();
  }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/ERC1155.sol)

pragma solidity ^0.8.0;

import "./IERC1155.sol";
import "./IERC1155Receiver.sol";
import "./extensions/IERC1155MetadataURI.sol";
import "../../utils/Address.sol";
import "../../utils/Context.sol";
import "../../utils/introspection/ERC165.sol";

/**
 * @dev Implementation of the basic standard multi-token.
 * See https://eips.ethereum.org/EIPS/eip-1155
 * Originally based on code by Enjin: https://github.com/enjin/erc-1155
 *
 * _Available since v3.1._
 */
contract ERC1155 is Context, ERC165, IERC1155, IERC1155MetadataURI {
    using Address for address;

    // Mapping from token ID to account balances
    mapping(uint256 => mapping(address => uint256)) private _balances;

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

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

    /**
     * @dev See {_setURI}.
     */
    constructor(string memory uri_) {
        _setURI(uri_);
    }

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

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

    /**
     * @dev See {IERC1155-balanceOf}.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function balanceOf(address account, uint256 id) public view virtual override returns (uint256) {
        require(account != address(0), "ERC1155: balance query for the zero address");
        return _balances[id][account];
    }

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

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

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

        return batchBalances;
    }

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

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

    /**
     * @dev See {IERC1155-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: caller is not owner nor approved"
        );
        _safeTransferFrom(from, to, id, amount, data);
    }

    /**
     * @dev See {IERC1155-safeBatchTransferFrom}.
     */
    function safeBatchTransferFrom(
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) public virtual override {
        require(
            from == _msgSender() || isApprovedForAll(from, _msgSender()),
            "ERC1155: transfer caller is not owner nor approved"
        );
        _safeBatchTransferFrom(from, to, ids, amounts, data);
    }

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

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, _asSingletonArray(id), _asSingletonArray(amount), data);

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }
        _balances[id][to] += amount;

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

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

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

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, to, ids, amounts, data);

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

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: insufficient balance for transfer");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
            _balances[id][to] += amount;
        }

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

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

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

    /**
     * @dev Creates `amount` tokens of token type `id`, and assigns them to `to`.
     *
     * Emits a {TransferSingle} event.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the
     * acceptance magic value.
     */
    function _mint(
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, address(0), to, _asSingletonArray(id), _asSingletonArray(amount), data);

        _balances[id][to] += amount;
        emit TransferSingle(operator, address(0), to, id, amount);

        _doSafeTransferAcceptanceCheck(operator, address(0), to, id, amount, data);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_mint}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the
     * acceptance magic value.
     */
    function _mintBatch(
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) internal virtual {
        require(to != address(0), "ERC1155: mint to the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

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

        for (uint256 i = 0; i < ids.length; i++) {
            _balances[ids[i]][to] += amounts[i];
        }

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

        _doSafeBatchTransferAcceptanceCheck(operator, address(0), to, ids, amounts, data);
    }

    /**
     * @dev Destroys `amount` tokens of token type `id` from `from`
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `from` must have at least `amount` tokens of token type `id`.
     */
    function _burn(
        address from,
        uint256 id,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");

        address operator = _msgSender();

        _beforeTokenTransfer(operator, from, address(0), _asSingletonArray(id), _asSingletonArray(amount), "");

        uint256 fromBalance = _balances[id][from];
        require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
        unchecked {
            _balances[id][from] = fromBalance - amount;
        }

        emit TransferSingle(operator, from, address(0), id, amount);
    }

    /**
     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {_burn}.
     *
     * Requirements:
     *
     * - `ids` and `amounts` must have the same length.
     */
    function _burnBatch(
        address from,
        uint256[] memory ids,
        uint256[] memory amounts
    ) internal virtual {
        require(from != address(0), "ERC1155: burn from the zero address");
        require(ids.length == amounts.length, "ERC1155: ids and amounts length mismatch");

        address operator = _msgSender();

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

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

            uint256 fromBalance = _balances[id][from];
            require(fromBalance >= amount, "ERC1155: burn amount exceeds balance");
            unchecked {
                _balances[id][from] = fromBalance - amount;
            }
        }

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

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

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

    function _doSafeTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256 id,
        uint256 amount,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155Received(operator, from, id, amount, data) returns (bytes4 response) {
                if (response != IERC1155Receiver.onERC1155Received.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

    function _doSafeBatchTransferAcceptanceCheck(
        address operator,
        address from,
        address to,
        uint256[] memory ids,
        uint256[] memory amounts,
        bytes memory data
    ) private {
        if (to.isContract()) {
            try IERC1155Receiver(to).onERC1155BatchReceived(operator, from, ids, amounts, data) returns (
                bytes4 response
            ) {
                if (response != IERC1155Receiver.onERC1155BatchReceived.selector) {
                    revert("ERC1155: ERC1155Receiver rejected tokens");
                }
            } catch Error(string memory reason) {
                revert(reason);
            } catch {
                revert("ERC1155: transfer to non ERC1155Receiver implementer");
            }
        }
    }

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

        return array;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/Context.sol";

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Counters.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/IERC1155.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/extensions/IERC1155MetadataURI.sol)

pragma solidity ^0.8.0;

import "../IERC1155.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;

import "./IERC165.sol";

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/utils/ERC1155Holder.sol)

pragma solidity ^0.8.0;

import "./ERC1155Receiver.sol";

/**
 * Simple implementation of `ERC1155Receiver` that will allow a contract to hold ERC1155 tokens.
 *
 * IMPORTANT: When inheriting this contract, you must include a way to use the received tokens, otherwise they will be
 * stuck.
 *
 * @dev _Available since v3.1._
 */
contract ERC1155Holder is ERC1155Receiver {
    function onERC1155Received(
        address,
        address,
        uint256,
        uint256,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155Received.selector;
    }

    function onERC1155BatchReceived(
        address,
        address,
        uint256[] memory,
        uint256[] memory,
        bytes memory
    ) public virtual override returns (bytes4) {
        return this.onERC1155BatchReceived.selector;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC1155/utils/ERC1155Receiver.sol)

pragma solidity ^0.8.0;

import "../IERC1155Receiver.sol";
import "../../../utils/introspection/ERC165.sol";

/**
 * @dev _Available since v3.1._
 */
abstract contract ERC1155Receiver is ERC165, IERC1155Receiver {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) {
        return interfaceId == type(IERC1155Receiver).interfaceId || super.supportsInterface(interfaceId);
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_parentAddr","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"}],"name":"addStakes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"bailoutAllStakes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"bailoutSingleStake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"bool","name":"_status","type":"bool"}],"name":"blacklistAddr","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAllStakedIds","outputs":[{"internalType":"uint256[]","name":"_allStakingIds","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_change","type":"uint256"}],"name":"getEmission","outputs":[{"components":[{"internalType":"uint256","name":"rate","type":"uint256"},{"internalType":"uint256","name":"timestamp","type":"uint256"}],"internalType":"struct Grill.Emission","name":"_emission","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getEmissionChanges","outputs":[{"internalType":"uint256","name":"_changes","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"getIdsOfAddr","outputs":[{"internalType":"uint256[]","name":"_addrStakes","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"getStake","outputs":[{"components":[{"internalType":"bool","name":"status","type":"bool"},{"internalType":"address","name":"staker","type":"address"},{"internalType":"uint256","name":"timestamp","type":"uint256"}],"internalType":"struct Grill.Stake","name":"_stake","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"getStakedClaims","outputs":[{"internalType":"uint256","name":"_total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"getTotalClaims","outputs":[{"internalType":"uint256","name":"_total","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"getUnstakedClaims","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isBailedOut","outputs":[{"internalType":"bool","name":"_b","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"isBlacklisted","outputs":[{"internalType":"bool","name":"_b","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isStakingActive","outputs":[{"internalType":"bool","name":"_b","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"uint256[]","name":"","type":"uint256[]"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155BatchReceived","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC1155Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"parentBalance","outputs":[{"internalType":"uint256","name":"_c","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pauseEmissions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"},{"internalType":"uint256[]","name":"_amounts","type":"uint256[]"}],"name":"removeStakes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_seconds","type":"uint256"}],"name":"setEmissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleBailout","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleStaking","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000071b11ac923c967cd5998f23f6dae0d779a6ac8af

-----Decoded View---------------
Arg [0] : _parentAddr (address): 0x71B11Ac923C967CD5998F23F6dae0d779A6ac8Af

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000071b11ac923c967cd5998f23f6dae0d779a6ac8af

2915:17962:13:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;387:221:6;;;;;;:::i;:::-;;:::i;:::-;;;470:14:14;;463:22;445:41;;433:2;418:18;387:221:6;;;;;;;;18465:222:13;;;;;;:::i;:::-;;:::i;:::-;;;;898:13:14;;880:32;;968:4;956:17;;;950:24;928:20;;;921:54;;;;853:18;18465:222:13;682:299:14;20692:183:13;;;;;;:::i;:::-;;:::i;:::-;;;1501:25:14;;;1489:2;1474:18;20692:183:13;1355:177:14;20024:119:13;;;;;;:::i;:::-;-1:-1:-1;;;;;20113:25:13;20091:7;20113:25;;;:14;:25;;;;;;;20024:119;18133:112;;;:::i;5881:152::-;;;:::i;:::-;;17376:160;;;;;;:::i;:::-;;:::i;17619:89::-;17669:7;17689:14;-1:-1:-1;;;17689:14:13;;;;17619:89;;8609:450;;;;;;:::i;:::-;;:::i;6622:81::-;;;:::i;1668:101:0:-;;;:::i;18772:272:13:-;;;:::i;:::-;;;;;;;:::i;1036:85:0:-;1082:7;1108:6;1036:85;;-1:-1:-1;;;;;1108:6:0;;;2648:51:14;;2636:2;2621:18;1036:85:0;2502:203:14;17776:81:13;17822:7;17842:10;-1:-1:-1;;;17842:10:13;;;;17776:81;;6842:177;;;;;;:::i;:::-;;:::i;19574:301::-;;;;;;:::i;:::-;;:::i;7248:190::-;;;:::i;724:247:5:-;;;;;;:::i;:::-;-1:-1:-1;;;724:247:5;;;;;;;;;;;-1:-1:-1;;;;;;5484:33:14;;;5466:52;;5454:2;5439:18;724:247:5;5322:202:14;9364:945:13;;;;;;:::i;:::-;;:::i;19241:200::-;;;;;;:::i;:::-;;:::i;:::-;;;;6353:13:14;;6346:21;6339:29;6321:48;;6429:4;6417:17;;;6411:24;-1:-1:-1;;;;;6407:50:14;6385:20;;;6378:80;6502:17;;;6496:24;6474:20;;;6467:54;6309:2;6294:18;19241:200:13;6129:398:14;10574:913:13;;;;;;:::i;:::-;;:::i;7551:868::-;;;:::i;6302:108::-;;;;;;:::i;:::-;;:::i;499:219:5:-;;;;;;:::i;:::-;-1:-1:-1;;;499:219:5;;;;;;;;1918:198:0;;;;;;:::i;:::-;;:::i;20292:242:13:-;;;;;;:::i;:::-;;:::i;17946:102::-;;;;;;:::i;:::-;-1:-1:-1;;;;;18027:16:13;18007:7;18027:16;;;:9;:16;;;;;;;;;17946:102;387:221:6;489:4;-1:-1:-1;;;;;;512:49:6;;-1:-1:-1;;;512:49:6;;:89;;-1:-1:-1;;;;;;;;;;937:40:10;;;565:36:6;505:96;387:221;-1:-1:-1;;387:221:6:o;18465:222:13:-;-1:-1:-1;;;;;;;;;;;;;;;;;18592:9:13;918:14:9;18581:7:13;:30;;18573:73;;;;-1:-1:-1;;;18573:73:13;;7788:2:14;18573:73:13;;;7770:21:14;7827:2;7807:18;;;7800:30;7866:32;7846:18;;;7839:60;7916:18;;18573:73:13;;;;;;;;;-1:-1:-1;18664:18:13;;;;:9;:18;;;;;;;;;18652:30;;;;;;;;;;;;;;;;;;;;18465:222::o;20692:183::-;-1:-1:-1;;;;;20803:25:13;;20770:14;20803:25;;;:14;:25;;;;;;20844:26;20818:9;20844:15;:26::i;:::-;20834:36;;;;:::i;18133:112::-;18186:16;18221:19;:9;918:14:9;;827:112;18221:19:13;18210:30;;18133:112;:::o;5881:152::-;1082:7:0;1108:6;-1:-1:-1;;;;;1108:6:0;719:10:8;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;;;;;;:::i;:::-;5940:10:13::1;::::0;-1:-1:-1;;;5940:10:13;::::1;;;5939:11;5931:59;;;::::0;-1:-1:-1;;;5931:59:13;;8773:2:14;5931:59:13::1;::::0;::::1;8755:21:14::0;8812:2;8792:18;;;8785:30;8851:34;8831:18;;;8824:62;-1:-1:-1;;;8902:18:14;;;8895:33;8945:19;;5931:59:13::1;8571:399:14::0;5931:59:13::1;6014:14;::::0;;-1:-1:-1;;;;5996:32:13;::::1;-1:-1:-1::0;;;6014:14:13;;;::::1;;;6013:15;5996:32:::0;;::::1;;::::0;;5881:152::o;17376:160::-;17494:37;;-1:-1:-1;;;17494:37:13;;-1:-1:-1;;;;;9167:32:14;;;17494:37:13;;;9149:51:14;9216:18;;;9209:34;;;17469:10:13;;17494:6;:16;;;;;;9122:18:14;;17494:37:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;17489:42;17376:160;-1:-1:-1;;;17376:160:13:o;8609:450::-;1082:7:0;1108:6;-1:-1:-1;;;;;1108:6:0;719:10:8;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;;;;;;:::i;:::-;8688:10:13::1;::::0;-1:-1:-1;;;8688:10:13;::::1;;;8680:66;;;;-1:-1:-1::0;;;8680:66:13::1;;;;;;;:::i;:::-;8805:16;::::0;;;:6:::1;:16;::::0;;;;;;;;:23;8753:119;;-1:-1:-1;;;8753:119:13;;-1:-1:-1;;;;;8753:6:13::1;:23:::0;::::1;::::0;::::1;::::0;:119:::1;::::0;8792:4:::1;::::0;8805:23:::1;::::0;;::::1;::::0;;::::1;::::0;8812:8;;8805:6;8753:119:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;8915:29;8947:17;8962:1;8947:14;:17::i;:::-;8915:49;;8988:8;8970:12;8983:1;8970:15;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;:26;;;;9016:16:::1;::::0;;;:6:::1;:16:::0;;;;;;:23;9002:52:::1;::::0;9016:23:::1;::::0;::::1;-1:-1:-1::0;;;;;9016:23:13::1;9041:12:::0;9002:13:::1;:52::i;:::-;8674:385;8609:450:::0;:::o;6622:81::-;1082:7:0;1108:6;-1:-1:-1;;;;;1108:6:0;719:10:8;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;;;;;;:::i;:::-;6673:25:13::1;-1:-1:-1::0;;6673:16:13::1;:25::i;:::-;6622:81::o:0;1668:101:0:-;1082:7;1108:6;-1:-1:-1;;;;;1108:6:0;719:10:8;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;;;;;;:::i;:::-;1732:30:::1;1759:1;1732:18;:30::i;18772:272:13:-:0;18834:31;18906:24;:14;918::9;;827:112;18906:24:13;18892:39;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18892:39:13;;18875:56;;18942:9;18937:103;18961:14;:21;18957:1;:25;18937:103;;;19017:9;:16;19027:5;:1;19031;19027:5;:::i;:::-;19017:16;;;;;;;;;;;;18997:14;19012:1;18997:17;;;;;;;;:::i;:::-;;;;;;;;;;:36;18984:3;;;:::i;:::-;;;18937:103;;;;18772:272;:::o;6842:177::-;1082:7:0;1108:6;-1:-1:-1;;;;;1108:6:0;719:10:8;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;;;;;;:::i;:::-;6919:10:13::1;::::0;-1:-1:-1;;;6919:10:13;::::1;;;6918:11;6910:72;;;::::0;-1:-1:-1;;;6910:72:13;;11117:2:14;6910:72:13::1;::::0;::::1;11099:21:14::0;11156:2;11136:18;;;11129:30;11195:34;11175:18;;;11168:62;-1:-1:-1;;;11246:18:14;;;11239:46;11302:19;;6910:72:13::1;10915:412:14::0;6910:72:13::1;6988:26;7005:8;6988:16;:26::i;:::-;6842:177:::0;:::o;19574:301::-;-1:-1:-1;;;;;19716:26:13;;;;;;:15;:26;;;;;918:14:9;19650:28:13;;19702:51;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;19702:51:13;;19688:65;;19764:9;19759:112;19783:11;:18;19779:1;:22;19759:112;;;-1:-1:-1;;;;;19833:24:13;;;;;;:13;:24;;;;;;19858:5;:1;19862;19858:5;:::i;:::-;19833:31;;;;;;;;;;;;19816:11;19828:1;19816:14;;;;;;;;:::i;:::-;;;;;;;;;;:48;19803:3;;;:::i;:::-;;;19759:112;;;;19574:301;;;:::o;7248:190::-;1082:7:0;1108:6;-1:-1:-1;;;;;1108:6:0;719:10:8;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;;;;;;:::i;:::-;7307:10:13::1;::::0;-1:-1:-1;;;7307:10:13;::::1;;;7306:11;7298:53;;;::::0;-1:-1:-1;;;7298:53:13;;11534:2:14;7298:53:13::1;::::0;::::1;11516:21:14::0;11573:2;11553:18;;;11546:30;11612:31;11592:18;;;11585:59;11661:18;;7298:53:13::1;11332:353:14::0;7298:53:13::1;7374:5;7357:22:::0;;-1:-1:-1;;;;7385:17:13;-1:-1:-1;;;7385:17:13::1;::::0;;7408:25:::1;-1:-1:-1::0;;7408:16:13::1;:25::i;9364:945::-:0;9467:14;;-1:-1:-1;;;9467:14:13;;;;9459:55;;;;-1:-1:-1;;;9459:55:13;;11892:2:14;9459:55:13;;;11874:21:14;11931:2;11911:18;;;11904:30;11970;11950:18;;;11943:58;12018:18;;9459:55:13;11690:352:14;9459:55:13;9539:10;9529:21;;;;:9;:21;;;;;;;;9528:22;9520:63;;;;-1:-1:-1;;;9520:63:13;;12249:2:14;9520:63:13;;;12231:21:14;12288:2;12268:18;;;12261:30;12327;12307:18;;;12300:58;12375:18;;9520:63:13;12047:352:14;9520:63:13;9616:1;9597:9;:16;:20;9589:69;;;;-1:-1:-1;;;9589:69:13;;12606:2:14;9589:69:13;;;12588:21:14;12645:2;12625:18;;;12618:30;12684:34;12664:18;;;12657:62;-1:-1:-1;;;12735:18:14;;;12728:34;12779:19;;9589:69:13;12404:400:14;9589:69:13;3338:2;9679:9;:16;:27;;9664:108;;;;-1:-1:-1;;;9664:108:13;;13011:2:14;9664:108:13;;;12993:21:14;13050:2;13030:18;;;13023:30;13089:34;13069:18;;;13062:62;-1:-1:-1;;;13140:18:14;;;13133:48;13198:19;;9664:108:13;12809:414:14;9664:108:13;9793:48;9809:10;9821:9;9832:8;9793:15;:48::i;:::-;9778:118;;;;-1:-1:-1;;;9778:118:13;;13430:2:14;9778:118:13;;;13412:21:14;13469:2;13449:18;;;13442:30;13508:34;13488:18;;;13481:62;-1:-1:-1;;;13559:18:14;;;13552:37;13606:19;;9778:118:13;13228:403:14;9778:118:13;9917:50;;-1:-1:-1;;;9917:50:13;;9941:10;9917:50;;;13848:34:14;9961:4:13;13898:18:14;;;13891:43;9917:6:13;-1:-1:-1;;;;;9917:23:13;;;;13783:18:14;;9917:50:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9902:144;;;;-1:-1:-1;;;9902:144:13;;14397:2:14;9902:144:13;;;14379:21:14;14436:2;14416:18;;;14409:30;14475:34;14455:18;;;14448:62;14546:33;14526:18;;;14519:61;14597:19;;9902:144:13;14195:427:14;9902:144:13;10112:119;;-1:-1:-1;;;10112:119:13;;-1:-1:-1;;;;;10112:6:13;:28;;;;:119;;10148:10;;10174:4;;10187:9;;10204:8;;10112:119;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10271:33;10282:10;10294:9;10271:10;:33::i;19241:200::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;19349:16:13;;;;:6;:16;;;;;:23;;;19341:64;;;;-1:-1:-1;;;19341:64:13;;15719:2:14;19341:64:13;;;15701:21:14;15758:2;15738:18;;;15731:30;15797;15777:18;;;15770:58;15845:18;;19341:64:13;15517:352:14;19341:64:13;-1:-1:-1;19420:16:13;;;;:6;:16;;;;;;;;;19411:25;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;19411:25:13;;;;;;;;;;;;;;;;;;;;19241:200::o;10574:913::-;10699:1;10680:9;:16;:20;10672:71;;;;-1:-1:-1;;;10672:71:13;;16076:2:14;10672:71:13;;;16058:21:14;16115:2;16095:18;;;16088:30;16154:34;16134:18;;;16127:62;-1:-1:-1;;;16205:18:14;;;16198:36;16251:19;;10672:71:13;15874:402:14;10672:71:13;3338:2;10764:9;:16;:27;;10749:118;;;;-1:-1:-1;;;10749:118:13;;16483:2:14;10749:118:13;;;16465:21:14;16522:2;16502:18;;;16495:30;16561:34;16541:18;;;16534:62;16632:30;16612:18;;;16605:58;16680:19;;10749:118:13;16281:424:14;10749:118:13;10901:8;:15;10881:9;:16;:35;10873:70;;;;-1:-1:-1;;;10873:70:13;;16912:2:14;10873:70:13;;;16894:21:14;16951:2;16931:18;;;16924:30;-1:-1:-1;;;16970:18:14;;;16963:52;17032:18;;10873:70:13;16710:346:14;10873:70:13;10964:49;10981:10;10993:9;11004:8;10964:16;:49::i;:::-;10949:128;;;;-1:-1:-1;;;10949:128:13;;17263:2:14;10949:128:13;;;17245:21:14;17302:2;17282:18;;;17275:30;17341:34;17321:18;;;17314:62;-1:-1:-1;;;17392:18:14;;;17385:46;17448:19;;10949:128:13;17061:412:14;10949:128:13;11134:10;11118:27;;;;:15;:27;;;;;918:14:9;11098:9:13;:16;:57;;11083:130;;;;-1:-1:-1;;;11083:130:13;;17680:2:14;11083:130:13;;;17662:21:14;17719:2;17699:18;;;17692:30;17758:34;17738:18;;;17731:62;-1:-1:-1;;;17809:18:14;;;17802:40;17859:19;;11083:130:13;17478:406:14;11083:130:13;11283:119;;-1:-1:-1;;;11283:119:13;;-1:-1:-1;;;;;11283:6:13;:28;;;;:119;;11327:4;;11340:10;;11358:9;;11375:8;;11283:119;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11446:36;11460:10;11472:9;11446:13;:36::i;7551:868::-;1082:7:0;1108:6;-1:-1:-1;;;;;1108:6:0;719:10:8;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;;;;;;:::i;:::-;7612:10:13::1;::::0;-1:-1:-1;;;7612:10:13;::::1;;;7604:66;;;;-1:-1:-1::0;;;7604:66:13::1;;;;;;;:::i;:::-;7741:19;7763:24;:14;918::9::0;;827:112;7763:24:13::1;7741:46:::0;-1:-1:-1;7810:1:13::1;7793:622;7818:11;7813:1;:16;7793:622;;7907:20;7930:9;:35;7940:24;:14;918::9::0;;827:112;7940:24:13::1;7930:35:::0;;::::1;::::0;;::::1;::::0;;;;;;;;-1:-1:-1;7930:35:13;;;;7991:20;;;:6:::1;:20:::0;;;;;;;;:27;8110:71;;-1:-1:-1;;;8110:71:13;;7930:35;;-1:-1:-1;;;;;;7991:27:13::1;::::0;;::::1;::::0;::::1;::::0;8110:6:::1;:23:::0;;::::1;::::0;::::1;::::0;:71:::1;::::0;8142:4:::1;::::0;7991:27;;7930:35;;8110:71:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;8228:29;8260:17;8275:1;8260:14;:17::i;:::-;8228:49;;8303:12;8285;8298:1;8285:15;;;;;;;;:::i;:::-;;;;;;:30;;;::::0;::::1;8372:36;8386:7;8395:12;8372:13;:36::i;:::-;7836:579;;;7831:3;;;;:::i;:::-;;;7793:622;;6302:108:::0;1082:7:0;1108:6;-1:-1:-1;;;;;1108:6:0;719:10:8;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;6379:16:13;;;::::1;;::::0;;;:9:::1;:16;::::0;;;;:26;;-1:-1:-1;;6379:26:13::1;::::0;::::1;;::::0;;;::::1;::::0;;6302:108::o;1918:198:0:-;1082:7;1108:6;-1:-1:-1;;;;;1108:6:0;719:10:8;1248:23:0;1240:68;;;;-1:-1:-1;;;1240:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2006:22:0;::::1;1998:73;;;::::0;-1:-1:-1;;;1998:73:0;;18091:2:14;1998:73:0::1;::::0;::::1;18073:21:14::0;18130:2;18110:18;;;18103:30;18169:34;18149:18;;;18142:62;-1:-1:-1;;;18220:18:14;;;18213:36;18266:19;;1998:73:0::1;17889:402:14::0;1998:73:0::1;2081:28;2100:8;2081:18;:28::i;20292:242:13:-:0;20369:14;20410:1;20393:137;-1:-1:-1;;;;;20418:26:13;;;;;;:15;:26;;;;;918:14:9;20413:1:13;:41;20393:137;;-1:-1:-1;;;;;20495:24:13;;;;;;:13;:24;;;;;;;;:27;;;;;;;;;20479:44;;:15;:44::i;:::-;20469:54;;;;:::i;:::-;;-1:-1:-1;20456:3:13;;;;:::i;:::-;;;;20393:137;;827:112:9;918:14;;827:112::o;16878:215:13:-;16948:22;17002:2;16988:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16988:17:13;;16980:25;;17016:9;17011:60;17035:2;17031:1;:6;17011:60;;;17063:1;17052:5;17058:1;17052:8;;;;;;;;:::i;:::-;;;;;;;;;;:12;17039:3;;;;:::i;:::-;;;;17011:60;;13885:1312;13972:9;13967:1226;13991:9;:16;13987:1;:20;13967:1226;;;14039:6;:20;14046:9;14056:1;14046:12;;;;;;;;:::i;:::-;;;;;;;;;;;;14039:20;;;;;;;;;;-1:-1:-1;14039:20:13;:27;;;14022:100;;;;-1:-1:-1;;;14022:100:13;;;;;;;:::i;:::-;14162:16;14181:9;14191:1;14181:12;;;;;;;;:::i;:::-;;;;;;;14162:31;;14228:25;14244:8;14228:15;:25::i;:::-;-1:-1:-1;;;;;14201:23:13;;;;;;:14;:23;;;;;:52;;:23;;;:52;;;;;:::i;:::-;;;;-1:-1:-1;;14328:16:13;;;;:6;:16;;;;;;;;14321:23;;-1:-1:-1;;;;;;14321:23:13;;;;;;;;-1:-1:-1;;;;;14399:24:13;;;;:15;:24;;;;;;918:14:9;14455::13;918::9;;;14560:171:13;14584:2;14580:1;:6;14560:171;;;-1:-1:-1;;;;;14607:22:13;;;;;;:13;:22;;;;;;;;:25;;;;;;;;;:37;;14603:120;;;-1:-1:-1;;;;;14686:22:13;;;;;;:13;:22;;;;;;;;:26;;;;;;;;;;14658:25;;;;;:54;14603:120;14588:3;;;:::i;:::-;;;14560:171;;;-1:-1:-1;14755:1:13;14738:134;14762:3;14758:1;:7;14738:134;;;14786:12;;;;:9;:12;;;;;;:24;;14782:82;;;14839:14;;;;:9;:14;;;;;;;14824:12;;;;;:29;14782:82;14767:3;;;:::i;:::-;;;14738:134;;;-1:-1:-1;;;;;;14931:22:13;;;;;;:13;:22;;;;;;;;:26;;;;;;;;14924:33;;;14972:14;;;:9;:14;;;;;14965:21;15057:7;;15053:68;;-1:-1:-1;;;;;15076:24:13;;;;;;:15;:24;;;;;:36;;:34;:36::i;:::-;15132:8;;15128:59;;15152:26;:14;:24;:26::i;:::-;14014:1179;;;14009:3;;;;:::i;:::-;;;13967:1226;;;;13885:1312;;:::o;15435:221::-;15512:1;15501:8;:12;15493:57;;;;-1:-1:-1;;;15493:57:13;;18903:2:14;15493:57:13;;;18885:21:14;;;18922:18;;;18915:30;18981:34;18961:18;;;18954:62;19033:18;;15493:57:13;18701:356:14;15493:57:13;15556:21;:9;1032:19:9;;1050:1;1032:19;;;945:123;15556:21:13;15616:35;;;;;;;;15625:8;15616:35;;;;15635:15;15616:35;;;15583:9;:30;15593:19;:9;918:14:9;;827:112;15593:19:13;15583:30;;;;;;;;;;;;-1:-1:-1;15583:30:13;:68;;;;;;;;;;;;-1:-1:-1;15435:221:13:o;2270:187:0:-;2343:16;2362:6;;-1:-1:-1;;;;;2378:17:0;;;-1:-1:-1;;;;;;2378:17:0;;;;;;2410:40;;2362:6;;;;;;;2410:40;;2343:16;2410:40;2333:124;2270:187;:::o;11908:345:13:-;12065:4;12045:7;12075:174;12099:9;:16;12095:1;:20;12075:174;;;12134:38;12148:9;12159;12169:1;12159:12;;;;;;;;:::i;:::-;;;;;;;12134:13;:38::i;:::-;:43;;:63;;;12181:8;12190:1;12181:11;;;;;;;;:::i;:::-;;;;;;;12196:1;12181:16;;12134:63;12130:113;;;12214:5;12209:10;;12229:5;;12130:113;12117:3;;;:::i;:::-;;;12075:174;;;;11908:345;;;;;:::o;13145:552::-;13229:9;13224:469;13248:9;:16;13244:1;:20;13224:469;;;13288:6;:20;13295:9;13305:1;13295:12;;;;;;;;:::i;:::-;;;;;;;;;;;;13288:20;;;;;;;;;;-1:-1:-1;13288:20:13;:27;;;13287:28;13279:68;;;;-1:-1:-1;;;13279:68:13;;19264:2:14;13279:68:13;;;19246:21:14;19303:2;19283:18;;;19276:30;19342:29;19322:18;;;19315:57;19389:18;;13279:68:13;19062:351:14;13279:68:13;-1:-1:-1;;;;;13385:24:13;;;;;;:15;:24;;;;;1032:19:9;;1050:1;1032:19;;;13429:26:13;:14;1032:19:9;;1050:1;1032:19;;;945:123;13429:26:13;13548:9;13558:1;13548:12;;;;;;;;:::i;:::-;;;;;;;;;;;;-1:-1:-1;;;;;13487:22:13;;;;;;:13;:22;;;;;;13510:15;:24;;;;;918:14:9;13487:58:13;;;;;;;;;:73;13606:12;;:9;;13616:1;;13606:12;;;;;;:::i;:::-;;;;;;;13568:9;:35;13578:24;:14;918::9;;827:112;13578:24:13;13568:35;;;;;;;;;;;:50;;;;13649:37;;;;;;;;13655:4;13649:37;;;;;;13661:7;-1:-1:-1;;;;;13649:37:13;;;;;13670:15;13649:37;;;13626:6;:20;13633:9;13643:1;13633:12;;;;;;;;:::i;:::-;;;;;;;;;;;;13626:20;;;;;;;;;;;;;-1:-1:-1;13626:20:13;:60;;;;;;;;-1:-1:-1;;;;;;13626:60:13;;;;;;-1:-1:-1;;;;;;13626:60:13;;;-1:-1:-1;;;;;13626:60:13;;;;;;;;;;;;;;;;;;-1:-1:-1;13626:60:13;;;;13266:3;;;:::i;:::-;;;13224:469;;12620:343;12778:4;12758:7;12788:171;12812:9;:16;12808:1;:20;12788:171;;;12878:9;-1:-1:-1;;;;;12847:40:13;:6;:20;12854:9;12864:1;12854:12;;;;;;;;:::i;:::-;;;;;;;;;;;;12847:20;;;;;;;;;;-1:-1:-1;12847:20:13;:27;;;;-1:-1:-1;;;;;12847:27:13;:40;;;:60;;;12891:8;12900:1;12891:11;;;;;;;;:::i;:::-;;;;;;;12906:1;12891:16;;12847:60;12843:110;;;12924:5;12919:10;;12939:5;;12843:110;12830:3;;;:::i;:::-;;;12788:171;;15845:855;15910:10;15936:16;;;:6;:16;;;;;:23;;;15928:72;;;;-1:-1:-1;;;15928:72:13;;;;;;;:::i;:::-;16078:12;16116:16;;;:6;:16;;;;;;;:26;;;;16148:133;16173:9;918:14:9;16168:1:13;:24;16148:133;;16211:12;;;;:9;:12;;;;;:22;;;:34;-1:-1:-1;16207:68:13;;;16257:9;16265:1;16257:9;;:::i;:::-;;;16207:68;16194:3;;;:::i;:::-;;;16148:133;;;-1:-1:-1;16370:4:13;16353:343;16381:9;918:14:9;16376:1:13;:24;16353:343;;16415:14;16432:12;;;:9;:12;;;;;;;:22;;;;;;16415:14;16432:9;16415:14;;16487:5;;16442:1;;16487:5;:::i;:::-;16477:16;;;;;;;;;;;:26;;;16462:41;;16520:4;16515:1;:9;16511:52;;;16545:9;16536:18;;16511:52;16579:9;918:14:9;16574:1:13;:24;16570:71;;;-1:-1:-1;16617:15:13;16570:71;16672:12;;;;:9;:12;;;;;:17;16655:13;16662:6;16655:4;:13;:::i;:::-;16654:35;;;;:::i;:::-;16648:41;;;;:::i;:::-;;;16407:289;;16402:3;;;;:::i;:::-;;;16353:343;;;;15922:778;;15845:855;;;:::o;1074:229:9:-;1153:14;;1185:9;1177:49;;;;-1:-1:-1;;;1177:49:9;;19972:2:14;1177:49:9;;;19954:21:14;20011:2;19991:18;;;19984:30;20050:29;20030:18;;;20023:57;20097:18;;1177:49:9;19770:351:14;1177:49:9;-1:-1:-1;;1277:9:9;1260:26;;1074:229::o;14:286:14:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:14;;209:43;;199:71;;266:1;263;256:12;497:180;556:6;609:2;597:9;588:7;584:23;580:32;577:52;;;625:1;622;615:12;577:52;-1:-1:-1;648:23:14;;497:180;-1:-1:-1;497:180:14:o;986:173::-;1054:20;;-1:-1:-1;;;;;1103:31:14;;1093:42;;1083:70;;1149:1;1146;1139:12;1083:70;986:173;;;:::o;1164:186::-;1223:6;1276:2;1264:9;1255:7;1251:23;1247:32;1244:52;;;1292:1;1289;1282:12;1244:52;1315:29;1334:9;1315:29;:::i;1537:254::-;1605:6;1613;1666:2;1654:9;1645:7;1641:23;1637:32;1634:52;;;1682:1;1679;1672:12;1634:52;1705:29;1724:9;1705:29;:::i;:::-;1695:39;1781:2;1766:18;;;;1753:32;;-1:-1:-1;;;1537:254:14:o;1796:435::-;1849:3;1887:5;1881:12;1914:6;1909:3;1902:19;1940:4;1969:2;1964:3;1960:12;1953:19;;2006:2;1999:5;1995:14;2027:1;2037:169;2051:6;2048:1;2045:13;2037:169;;;2112:13;;2100:26;;2146:12;;;;2181:15;;;;2073:1;2066:9;2037:169;;;-1:-1:-1;2222:3:14;;1796:435;-1:-1:-1;;;;;1796:435:14:o;2236:261::-;2415:2;2404:9;2397:21;2378:4;2435:56;2487:2;2476:9;2472:18;2464:6;2435:56;:::i;2710:127::-;2771:10;2766:3;2762:20;2759:1;2752:31;2802:4;2799:1;2792:15;2826:4;2823:1;2816:15;2842:275;2913:2;2907:9;2978:2;2959:13;;-1:-1:-1;;2955:27:14;2943:40;;3013:18;2998:34;;3034:22;;;2995:62;2992:88;;;3060:18;;:::i;:::-;3096:2;3089:22;2842:275;;-1:-1:-1;2842:275:14:o;3122:712::-;3176:5;3229:3;3222:4;3214:6;3210:17;3206:27;3196:55;;3247:1;3244;3237:12;3196:55;3283:6;3270:20;3309:4;3332:18;3328:2;3325:26;3322:52;;;3354:18;;:::i;:::-;3400:2;3397:1;3393:10;3423:28;3447:2;3443;3439:11;3423:28;:::i;:::-;3485:15;;;3555;;;3551:24;;;3516:12;;;;3587:15;;;3584:35;;;3615:1;3612;3605:12;3584:35;3651:2;3643:6;3639:15;3628:26;;3663:142;3679:6;3674:3;3671:15;3663:142;;;3745:17;;3733:30;;3696:12;;;;3783;;;;3663:142;;;3823:5;3122:712;-1:-1:-1;;;;;;;3122:712:14:o;3839:530::-;3881:5;3934:3;3927:4;3919:6;3915:17;3911:27;3901:55;;3952:1;3949;3942:12;3901:55;3988:6;3975:20;4014:18;4010:2;4007:26;4004:52;;;4036:18;;:::i;:::-;4080:55;4123:2;4104:13;;-1:-1:-1;;4100:27:14;4129:4;4096:38;4080:55;:::i;:::-;4160:2;4151:7;4144:19;4206:3;4199:4;4194:2;4186:6;4182:15;4178:26;4175:35;4172:55;;;4223:1;4220;4213:12;4172:55;4288:2;4281:4;4273:6;4269:17;4262:4;4253:7;4249:18;4236:55;4336:1;4311:16;;;4329:4;4307:27;4300:38;;;;4315:7;3839:530;-1:-1:-1;;;3839:530:14:o;4374:943::-;4528:6;4536;4544;4552;4560;4613:3;4601:9;4592:7;4588:23;4584:33;4581:53;;;4630:1;4627;4620:12;4581:53;4653:29;4672:9;4653:29;:::i;:::-;4643:39;;4701:38;4735:2;4724:9;4720:18;4701:38;:::i;:::-;4691:48;;4790:2;4779:9;4775:18;4762:32;4813:18;4854:2;4846:6;4843:14;4840:34;;;4870:1;4867;4860:12;4840:34;4893:61;4946:7;4937:6;4926:9;4922:22;4893:61;:::i;:::-;4883:71;;5007:2;4996:9;4992:18;4979:32;4963:48;;5036:2;5026:8;5023:16;5020:36;;;5052:1;5049;5042:12;5020:36;5075:63;5130:7;5119:8;5108:9;5104:24;5075:63;:::i;:::-;5065:73;;5191:3;5180:9;5176:19;5163:33;5147:49;;5221:2;5211:8;5208:16;5205:36;;;5237:1;5234;5227:12;5205:36;;5260:51;5303:7;5292:8;5281:9;5277:24;5260:51;:::i;:::-;5250:61;;;4374:943;;;;;;;;:::o;5529:595::-;5647:6;5655;5708:2;5696:9;5687:7;5683:23;5679:32;5676:52;;;5724:1;5721;5714:12;5676:52;5764:9;5751:23;5793:18;5834:2;5826:6;5823:14;5820:34;;;5850:1;5847;5840:12;5820:34;5873:61;5926:7;5917:6;5906:9;5902:22;5873:61;:::i;:::-;5863:71;;5987:2;5976:9;5972:18;5959:32;5943:48;;6016:2;6006:8;6003:16;6000:36;;;6032:1;6029;6022:12;6000:36;;6055:63;6110:7;6099:8;6088:9;6084:24;6055:63;:::i;:::-;6045:73;;;5529:595;;;;;:::o;6532:118::-;6618:5;6611:13;6604:21;6597:5;6594:32;6584:60;;6640:1;6637;6630:12;6655:315;6720:6;6728;6781:2;6769:9;6760:7;6756:23;6752:32;6749:52;;;6797:1;6794;6787:12;6749:52;6820:29;6839:9;6820:29;:::i;:::-;6810:39;;6899:2;6888:9;6884:18;6871:32;6912:28;6934:5;6912:28;:::i;:::-;6959:5;6949:15;;;6655:315;;;;;:::o;6975:606::-;7079:6;7087;7095;7103;7111;7164:3;7152:9;7143:7;7139:23;7135:33;7132:53;;;7181:1;7178;7171:12;7132:53;7204:29;7223:9;7204:29;:::i;:::-;7194:39;;7252:38;7286:2;7275:9;7271:18;7252:38;:::i;:::-;7242:48;;7337:2;7326:9;7322:18;7309:32;7299:42;;7388:2;7377:9;7373:18;7360:32;7350:42;;7443:3;7432:9;7428:19;7415:33;7471:18;7463:6;7460:30;7457:50;;;7503:1;7500;7493:12;7457:50;7526:49;7567:7;7558:6;7547:9;7543:22;7526:49;:::i;7945:127::-;8006:10;8001:3;7997:20;7994:1;7987:31;8037:4;8034:1;8027:15;8061:4;8058:1;8051:15;8077:128;8117:3;8148:1;8144:6;8141:1;8138:13;8135:39;;;8154:18;;:::i;:::-;-1:-1:-1;8190:9:14;;8077:128::o;8210:356::-;8412:2;8394:21;;;8431:18;;;8424:30;8490:34;8485:2;8470:18;;8463:62;8557:2;8542:18;;8210:356::o;9254:184::-;9324:6;9377:2;9365:9;9356:7;9352:23;9348:32;9345:52;;;9393:1;9390;9383:12;9345:52;-1:-1:-1;9416:16:14;;9254:184;-1:-1:-1;9254:184:14:o;9443:407::-;9645:2;9627:21;;;9684:2;9664:18;;;9657:30;9723:34;9718:2;9703:18;;9696:62;-1:-1:-1;;;9789:2:14;9774:18;;9767:41;9840:3;9825:19;;9443:407::o;10011:627::-;-1:-1:-1;;;;;10370:15:14;;;10352:34;;10422:15;;;;10417:2;10402:18;;10395:43;10469:2;10454:18;;10447:34;10512:2;10497:18;;10490:34;;;;10332:3;10555;10540:19;;10533:32;;;9932:1;10612:19;;;9920:14;-1:-1:-1;;;9950:14:14;;;9943:29;9988:12;;;10011:627::o;10643:127::-;10704:10;10699:3;10695:20;10692:1;10685:31;10735:4;10732:1;10725:15;10759:4;10756:1;10749:15;10775:135;10814:3;-1:-1:-1;;10835:17:14;;10832:43;;;10855:18;;:::i;:::-;-1:-1:-1;10902:1:14;10891:13;;10775:135::o;13945:245::-;14012:6;14065:2;14053:9;14044:7;14040:23;14036:32;14033:52;;;14081:1;14078;14071:12;14033:52;14113:9;14107:16;14132:28;14154:5;14132:28;:::i;14627:885::-;-1:-1:-1;;;;;15078:15:14;;;15060:34;;15130:15;;15125:2;15110:18;;15103:43;15040:3;15177:2;15162:18;;15155:31;;;15003:4;;15209:57;;15246:19;;15238:6;15209:57;:::i;:::-;15314:9;15306:6;15302:22;15297:2;15286:9;15282:18;15275:50;15348:44;15385:6;15377;15348:44;:::i;:::-;15429:22;;;15423:3;15408:19;;15401:51;9932:1;9920:14;;-1:-1:-1;;;9959:4:14;9950:14;;9943:29;15334:58;-1:-1:-1;9997:2:14;9988:12;;15469:37;9855:151;18296:400;18498:2;18480:21;;;18537:2;18517:18;;;18510:30;18576:34;18571:2;18556:18;;18549:62;-1:-1:-1;;;18642:2:14;18627:18;;18620:34;18686:3;18671:19;;18296:400::o;19418:125::-;19458:4;19486:1;19483;19480:8;19477:34;;;19491:18;;:::i;:::-;-1:-1:-1;19528:9:14;;19418:125::o;19548:217::-;19588:1;19614;19604:132;;19658:10;19653:3;19649:20;19646:1;19639:31;19693:4;19690:1;19683:15;19721:4;19718:1;19711:15;19604:132;-1:-1:-1;19750:9:14;;19548:217::o

ipfs://0cac5565302a2a55bdd59598d1a4df441b3a6609aeaa4ae9e3980c70be7deb21