Contract 0x377aE58D7C680F0FB7Ca25018e3377EdE11120c9 4

import "./Ownable.sol";
import "./Pausable.sol";
import "./ERC721Enumerable.sol";
import "./Hunter.sol";
import "./GEM.sol";

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

contract Barn is Ownable, IERC721Receiver, Pausable {
    // maximum alpha score for a Hunter
    uint8 public constant MAX_ALPHA = 8;

    // struct to store a stake's token, owner, and earning values
    struct Stake {
        uint16 tokenId;
        uint80 value;
        address owner;
    }

    event TokenStaked(address owner, uint256 tokenId, uint256 value);
    event AdventurerClaimed(uint256 tokenId, uint256 earned, bool unstaked);
    event HunterClaimed(uint256 tokenId, uint256 earned, bool unstaked);

    // reference to the Hunter NFT contract
    Hunter hunter;
    // reference to the $GEM contract for minting $GEM earnings
    GEM gem;

    // maps tokenId to stake
    mapping(uint256 => Stake) public barn;
    // maps alpha to all hunter stakes with that alpha
    mapping(uint256 => Stake[]) public pack;
    // tracks location of each Hunter in Pack
    mapping(uint256 => uint256) public packIndices;
    // total alpha scores staked
    uint256 public totalAlphaStaked = 0;
    // any rewards distributed when no hunters are staked
    uint256 public unaccountedRewards = 0;
    // amount of $GEM due for each alpha point staked
    uint256 public gemPerAlpha = 0;

    // adventurer earn 10000 $GEM per day
    uint256 public constant DAILY_GEM_RATE = 10000 ether;
    // adventurer must have 2 days worth of $GEM to unstake or else it's too cold
    uint256 public constant MINIMUM_TO_EXIT = 2 days;
    // hunters take a 20% tax on all $GEM claimed
    uint256 public constant GEM_CLAIM_TAX_PERCENTAGE = 20;
    // there will only ever be (roughly) 2.4 billion $GEM earned through staking
    uint256 public MAXIMUM_GLOBAL_GEM = 2400000000 ether;
    //tax on claim
    uint256 public CLAIMING_FEE = 0.01 ether;

    // amount of $GEM earned so far
    uint256 public totalGemEarned;
    // number of Adventurer staked in the Barn
    uint256 public totalAdventurerStaked;
    // the last time $GEM was claimed
    uint256 public lastClaimTimestamp;

    // emergency rescue to allow unstaking without any checks but without $GEM
    bool public rescueEnabled = false;

    /**
     * @param _hunter reference to the Hunter NFT contract
     * @param _gem reference to the $GEM token
     */
    constructor(address _hunter, address _gem) {
        hunter = Hunter(_hunter);
        gem = GEM(_gem);
    }

    function setMAXIMUM_GLOBAL_GEM(uint256 _MAXIMUM_GLOBAL_GEM)
        external
        onlyOwner
    {
        MAXIMUM_GLOBAL_GEM = _MAXIMUM_GLOBAL_GEM;
    }

    //if its wrong
    function setClaimingFee(uint256 _newfee) external onlyOwner {
        CLAIMING_FEE = _newfee;
    }

    /** STAKING */

    /**
     * adds Adventurer and Hunters to the Barn and Pack
     * @param account the address of the staker
     * @param tokenIds the IDs of the Adventurer and Hunters to stake
     */
    function addManyToBarnAndPack(address account, uint16[] memory tokenIds)
        external
    {
        require(
            (account == _msgSender() && account == tx.origin) ||
                _msgSender() == address(hunter),
            "DONT GIVE YOUR TOKENS AWAY"
        );
        for (uint256 i = 0; i < tokenIds.length; i++) {
            if (_msgSender() != address(hunter)) {
                // dont do this step if its a mint + stake
                require(
                    hunter.ownerOf(tokenIds[i]) == _msgSender(),
                    "AINT YO TOKEN"
                );
                hunter.transferFrom(_msgSender(), address(this), tokenIds[i]);
            } else if (tokenIds[i] == 0) {
                continue; // there may be gaps in the array for stolen tokens
            }

            if (isAdventurer(tokenIds[i]))
                _addAdventurerToBarn(account, tokenIds[i]);
            else _addHunterToPack(account, tokenIds[i]);
        }
    }

    /**
     * adds a single Adventurer to the Barn
     * @param account the address of the staker
     * @param tokenId the ID of the Adventurer to add to the Barn
     */
    function _addAdventurerToBarn(address account, uint256 tokenId)
        internal
        whenNotPaused
        _updateEarnings
    {
        barn[tokenId] = Stake({
            owner: account,
            tokenId: uint16(tokenId),
            value: uint80(block.timestamp)
        });
        totalAdventurerStaked += 1;
        emit TokenStaked(account, tokenId, block.timestamp);
    }

    /**
     * adds a single Hunter to the Pack
     * @param account the address of the staker
     * @param tokenId the ID of the Hunter to add to the Pack
     */
    function _addHunterToPack(address account, uint256 tokenId) internal {
        uint256 alpha = _alphaForHunter(tokenId);
        totalAlphaStaked += alpha; // Portion of earnings ranges from 8 to 5
        packIndices[tokenId] = pack[alpha].length; // Store the location of the hunter in the Pack
        pack[alpha].push(
            Stake({
                owner: account,
                tokenId: uint16(tokenId),
                value: uint80(gemPerAlpha)
            })
        ); // Add the hunter to the Pack
        emit TokenStaked(account, tokenId, gemPerAlpha);
    }

    /** CLAIMING / UNSTAKING */

    /**
     * realize $GEM earnings and optionally unstake tokens from the Barn / Pack
     * to unstake a Adventurer it will require it has 2 days worth of $GEM unclaimed
     * @param tokenIds the IDs of the tokens to claim earnings from
     * @param unstake whether or not to unstake ALL of the tokens listed in tokenIds
     */
    function claimManyFromBarnAndPack(uint16[] memory tokenIds, bool unstake)
        external
        payable
        whenNotPaused
        _updateEarnings
    {
        //payable with the tax
        require(
            msg.value >= tokenIds.length * CLAIMING_FEE,
            "you didnt pay tax"
        );
        uint256 owed = 0;
        for (uint256 i = 0; i < tokenIds.length; i++) {
            if (isAdventurer(tokenIds[i]))
                owed += _claimAdventurerFromBarn(tokenIds[i], unstake);
            else owed += _claimHunterFromPack(tokenIds[i], unstake);
        }
        //fee transfer

        if (owed == 0) return;
        gem.mint(_msgSender(), owed);
    }

    function calculateRewards(uint256 tokenId)
        external
        view
        returns (uint256 owed)
    {
        if (hunter.getTokenTraits(tokenId).isAdventurer) {
            Stake memory stake = barn[tokenId];
            if (totalGemEarned < MAXIMUM_GLOBAL_GEM) {
                owed =
                    ((block.timestamp - stake.value) * DAILY_GEM_RATE) /
                    1 days;
            } else if (stake.value > lastClaimTimestamp) {
                owed = 0; // $GEM production stopped already
            } else {
                owed =
                    ((lastClaimTimestamp - stake.value) * DAILY_GEM_RATE) /
                    1 days; // stop earning additional $GEM if it's all been earned
            }
        } else {
            uint256 alpha = _alphaForHunter(tokenId);
            Stake memory stake = pack[alpha][packIndices[tokenId]];
            owed = (alpha) * (gemPerAlpha - stake.value);
        }
    }

    /**
     * realize $GEM earnings for a single Adventurer and optionally unstake it
     * if not unstaking, pay a 20% tax to the staked Hunters
     * if unstaking, there is a 50% chance all $GEM is stolen
     * @param tokenId the ID of the Adventurer to claim earnings from
     * @param unstake whether or not to unstake the Adventurer
     * @return owed - the amount of $GEM earned
     */
    function _claimAdventurerFromBarn(uint256 tokenId, bool unstake)
        internal
        returns (uint256 owed)
    {
        Stake memory stake = barn[tokenId];
        require(stake.owner == _msgSender(), "SWIPER, NO SWIPING");
        require(
            !(unstake && block.timestamp - stake.value < MINIMUM_TO_EXIT),
            "GONNA BE COLD WITHOUT TWO DAY'S GEM"
        );
        if (totalGemEarned < MAXIMUM_GLOBAL_GEM) {
            owed = ((block.timestamp - stake.value) * DAILY_GEM_RATE) / 1 days;
        } else if (stake.value > lastClaimTimestamp) {
            owed = 0; // $GEM production stopped already
        } else {
            owed =
                ((lastClaimTimestamp - stake.value) * DAILY_GEM_RATE) /
                1 days; // stop earning additional $GEM if it's all been earned
        }
        if (unstake) {
            if (random(tokenId) & 1 == 1) {
                // 50% chance of all $GEM stolen
                _payHunterTax(owed);
                owed = 0;
            }
            hunter.safeTransferFrom(address(this), _msgSender(), tokenId, ""); // send back Adventurer
            delete barn[tokenId];
            totalAdventurerStaked -= 1;
        } else {
            _payHunterTax((owed * GEM_CLAIM_TAX_PERCENTAGE) / 100); // percentage tax to staked hunters
            owed = (owed * (100 - GEM_CLAIM_TAX_PERCENTAGE)) / 100; // remainder goes to Adventurer owner
            barn[tokenId] = Stake({
                owner: _msgSender(),
                tokenId: uint16(tokenId),
                value: uint80(block.timestamp)
            }); // reset stake
        }
        emit AdventurerClaimed(tokenId, owed, unstake);
    }

    /**
     * realize $GEM earnings for a single Hunter and optionally unstake it
     * Hunters earn $GEM proportional to their Alpha rank
     * @param tokenId the ID of the hunter to claim earnings from
     * @param unstake whether or not to unstake the Hunter
     * @return owed - the amount of $GEM earned
     */
    function _claimHunterFromPack(uint256 tokenId, bool unstake)
        internal
        returns (uint256 owed)
    {
        require(
            hunter.ownerOf(tokenId) == address(this),
            "AINT A PART OF THE PACK"
        );
        uint256 alpha = _alphaForHunter(tokenId);
        Stake memory stake = pack[alpha][packIndices[tokenId]];
        require(stake.owner == _msgSender(), "SWIPER, NO SWIPING");
        owed = (alpha) * (gemPerAlpha - stake.value); // Calculate portion of tokens based on Alpha
        if (unstake) {
            totalAlphaStaked -= alpha; // Remove Alpha from total staked
            hunter.safeTransferFrom(address(this), _msgSender(), tokenId, ""); // Send back Hunter
            Stake memory lastStake = pack[alpha][pack[alpha].length - 1];
            pack[alpha][packIndices[tokenId]] = lastStake; // Shuffle last Hunter to current position
            packIndices[lastStake.tokenId] = packIndices[tokenId];
            pack[alpha].pop(); // Remove duplicate
            delete packIndices[tokenId]; // Delete old mapping
        } else {
            pack[alpha][packIndices[tokenId]] = Stake({
                owner: _msgSender(),
                tokenId: uint16(tokenId),
                value: uint80(gemPerAlpha)
            }); // reset stake
        }
        emit HunterClaimed(tokenId, owed, unstake);
    }

    /**
     * emergency unstake tokens
     * @param tokenIds the IDs of the tokens to claim earnings from
     */
    function rescue(uint256[] calldata tokenIds) external {
        require(rescueEnabled, "RESCUE DISABLED");
        uint256 tokenId;
        Stake memory stake;
        Stake memory lastStake;
        uint256 alpha;
        for (uint256 i = 0; i < tokenIds.length; i++) {
            tokenId = tokenIds[i];
            if (isAdventurer(tokenId)) {
                stake = barn[tokenId];
                require(stake.owner == _msgSender(), "SWIPER, NO SWIPING");
                hunter.safeTransferFrom(
                    address(this),
                    _msgSender(),
                    tokenId,
                    ""
                ); // send back Adventurer
                delete barn[tokenId];
                totalAdventurerStaked -= 1;
                emit AdventurerClaimed(tokenId, 0, true);
            } else {
                alpha = _alphaForHunter(tokenId);
                stake = pack[alpha][packIndices[tokenId]];
                require(stake.owner == _msgSender(), "SWIPER, NO SWIPING");
                totalAlphaStaked -= alpha; // Remove Alpha from total staked
                hunter.safeTransferFrom(
                    address(this),
                    _msgSender(),
                    tokenId,
                    ""
                ); // Send back Hunter
                lastStake = pack[alpha][pack[alpha].length - 1];
                pack[alpha][packIndices[tokenId]] = lastStake; // Shuffle last Hunter to current position
                packIndices[lastStake.tokenId] = packIndices[tokenId];
                pack[alpha].pop(); // Remove duplicate
                delete packIndices[tokenId]; // Delete old mapping
                emit HunterClaimed(tokenId, 0, true);
            }
        }
    }

    /** ACCOUNTING */

    /**
     * add $GEM to claimable pot for the Pack
     * @param amount $GEM to add to the pot
     */
    function _payHunterTax(uint256 amount) internal {
        if (totalAlphaStaked == 0) {
            // if there's no staked hunters
            unaccountedRewards += amount; // keep track of $GEM due to hunters
            return;
        }
        // makes sure to include any unaccounted $GEM
        gemPerAlpha += (amount + unaccountedRewards) / totalAlphaStaked;
        unaccountedRewards = 0;
    }

    /**
     * tracks $GEM earnings to ensure it stops once 2.4 billion is eclipsed
     */
    modifier _updateEarnings() {
        if (totalGemEarned < MAXIMUM_GLOBAL_GEM) {
            totalGemEarned +=
                ((block.timestamp - lastClaimTimestamp) *
                    totalAdventurerStaked *
                    DAILY_GEM_RATE) /
                1 days;
            lastClaimTimestamp = block.timestamp;
        }
        _;
    }

    /** ADMIN */

    /**
     * allows owner to enable "rescue mode"
     * simplifies accounting, prioritizes tokens out in emergency
     */
    function setRescueEnabled(bool _enabled) external onlyOwner {
        rescueEnabled = _enabled;
    }

    /**
     * enables owner to pause / unpause minting
     */
    function setPaused(bool _paused) external onlyOwner {
        if (_paused) _pause();
        else _unpause();
    }

    /** READ ONLY */

    /**
     * checks if a token is a Adventurer
     * @param tokenId the ID of the token to check
     * @return adventurer - whether or not a token is a Adventurer
     */
    function isAdventurer(uint256 tokenId)
        public
        view
        returns (bool adventurer)
    {
        (adventurer, , , , , , , , ) = hunter.tokenTraits(tokenId);
    }

    /**
     * gets the alpha score for a Hunter
     * @param tokenId the ID of the Hunter to get the alpha score for
     * @return the alpha score of the Hunter (5-8)
     */
    function _alphaForHunter(uint256 tokenId) internal view returns (uint8) {
        (, , , , , , , , uint8 alphaIndex) = hunter.tokenTraits(tokenId);
        return MAX_ALPHA - alphaIndex; // alpha index is 0-3
    }

    /*
     * chooses a random Hunter thief when a newly minted token is stolen
     * @param seed a random value to choose a Hunter from
     * @return the owner of the randomly selected Hunter thief
     */
    function randomHunterOwner(uint256 seed) external view returns (address) {
        if (totalAlphaStaked == 0) return address(0x0);
        uint256 bucket = (seed & 0xFFFFFFFF) % totalAlphaStaked; // choose a value from 0 to total alpha staked
        uint256 cumulative;
        seed >>= 32;
        // loop through each bucket of Hunters with the same alpha score
        for (uint256 i = MAX_ALPHA - 3; i <= MAX_ALPHA; i++) {
            cumulative += pack[i].length * i;
            // if the value is not inside of that bucket, keep going
            if (bucket >= cumulative) continue;
            // get the address of a random Hunter with that alpha score
            return pack[i][seed % pack[i].length].owner;
        }
        return address(0x0);
    }

    /**
     * generates a pseudorandom number
     * @param seed a value ensure different outcomes for different sources in the same block
     * @return a pseudorandom value
     */
    function random(uint256 seed) internal view returns (uint256) {
        return
            uint256(
                keccak256(
                    abi.encodePacked(
                        msg.sender,
                        blockhash(block.number - 1),
                        block.timestamp,
                        seed
                    )
                )
            );
    }

    function onERC721Received(
        address,
        address from,
        uint256,
        bytes calldata
    ) external pure override returns (bytes4) {
        require(from == address(0x0), "Cannot send tokens to Barn directly");
        return IERC721Receiver.onERC721Received.selector;
    }

    function withdraw() external onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }
}

// SPDX-License-Identifier: MIT
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;
    }
}

import "./Context.sol";
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount)
        external
        returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender)
        public
        view
        virtual
        override
        returns (uint256)
    {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount)
        public
        virtual
        override
        returns (bool)
    {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(
            currentAllowance >= amount,
            "ERC20: transfer amount exceeds allowance"
        );
        unchecked {
            _approve(sender, _msgSender(), currentAllowance - amount);
        }

        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue)
        public
        virtual
        returns (bool)
    {
        _approve(
            _msgSender(),
            spender,
            _allowances[_msgSender()][spender] + addedValue
        );
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue)
        public
        virtual
        returns (bool)
    {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(
            currentAllowance >= subtractedValue,
            "ERC20: decreased allowance below zero"
        );
        unchecked {
            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(
            senderBalance >= amount,
            "ERC20: transfer amount exceeds balance"
        );
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

import "./Context.sol";
import "./Libraries.sol";
// SPDX-License-Identifier: MIT
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);
}
/**
 * @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;
    }
}
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(
        address indexed from,
        address indexed to,
        uint256 indexed tokenId
    );

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

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

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

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

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

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

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

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

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

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

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


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

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

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

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

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

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner)
        public
        view
        virtual
        override
        returns (uint256)
    {
        require(
            owner != address(0),
            "ERC721: balance query for the zero address"
        );
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        address owner = _owners[tokenId];
        require(
            owner != address(0),
            "ERC721: owner query for nonexistent token"
        );
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );

        string memory baseURI = _baseURI();
        return
            bytes(baseURI).length > 0
                ? string(abi.encodePacked(baseURI, tokenId.toString()))
                : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId)
        public
        view
        virtual
        override
        returns (address)
    {
        require(
            _exists(tokenId),
            "ERC721: approved query for nonexistent token"
        );

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved)
        public
        virtual
        override
    {
        require(operator != _msgSender(), "ERC721: approve to caller");

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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

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


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

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

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

/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index)
        public
        view
        virtual
        override
        returns (uint256)
    {
        require(
            index < ERC721.balanceOf(owner),
            "ERC721Enumerable: owner index out of bounds"
        );
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index)
        public
        view
        virtual
        override
        returns (uint256)
    {
        require(
            index < ERC721Enumerable.totalSupply(),
            "ERC721Enumerable: global index out of bounds"
        );
        return _allTokens[index];
    }

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

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId)
        private
    {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}

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

import "./ERC20.sol";
import "./Ownable.sol";
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

pragma solidity ^0.8.0;
 

contract GEM is ERC20, Ownable {

  // a mapping from an address to whether or not it can mint / burn
  mapping(address => bool) controllers;
  constructor() ERC20("GEM", "GEM") { }

  /**
   * mints $GEM to a recipient
   * @param to the recipient of the $GEM
   * @param amount the amount of $GEM to mint
   */
  function mint(address to, uint256 amount) external {
    require(controllers[msg.sender], "Only controllers can mint");
    _mint(to, amount);
  }

  /**
   * burns $GEM from a holder
   * @param from the holder of the $GEM
   * @param amount the amount of $GEM to burn
   */
  function burn(address from, uint256 amount) external {
    require(controllers[msg.sender], "Only controllers can burn");
    _burn(from, amount);
  }

  /**
   * enables an address to mint / burn
   * @param controller the address to enable
   */
   function addController(address controller) external onlyOwner {
        controllers[controller] = true;
    }
  /**
   * disables an address from minting / burning
   * @param controller the address to disbale
   */
   function removeController(address controller) external onlyOwner {
        controllers[controller] = false;
    }
}

import "./IHunter.sol";
import "./ERC721Enumerable.sol";
import "./Ownable.sol";
import "./Pausable.sol";
import "./IBarn.sol";
import "./IGEM.sol";
import "./ITraits.sol";
import "./ISeed.sol";

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

contract Hunter is IHunter, ERC721Enumerable, Ownable, Pausable {
    // uint256 public constant MAX_PER_MINT = 10;
    // mint price 1.5AVAX
    uint256 public constant MINT_PRICE = 1.5 ether;

    //whitelist price  1.25 avax
    uint256 public constant WL_PRICE = 1.25 ether;
    // max number of tokens that can be minted - 50000 in production
    uint256 public MAX_TOKENS;
    // number of tokens that can be claimed for free - 20% of MAX_TOKENS
    uint256 public PAID_TOKENS;
    // number of tokens have been minted so far
    uint16 public minted;
    uint16 public Adventurer_minted;
    uint16 public Hunter_minted;
    // Pre mint
    uint256 public startTimestamp;
    uint256 public endTimestamp;

    // payment wallets
    address payable AdminWallet;
    address payable Multisig;

    // mapping from tokenId to a struct containing the token's traits
    mapping(uint256 => AvtHtr) public tokenTraits;

    // WhiteList
    mapping(address => bool) public WhiteList;

    mapping(address => uint256) public whiteListMintCounts;

    // list of probabilities for each trait type
    // 0 - 6 are associated with Adventurers, 7 - 12 are associated with hunters
    uint8[][12] public rarities;
    // list of aliases for Walker's Alias algorithm
    // 0 - 6 are associated with Adventurers, 6 - 12 are associated with Hunters
    uint8[][12] public aliases;

    // reference to the Barn for choosing random Hunter thieves
    IBarn public barn;
    // reference to $GEM for burning on mint
    IGEM public gem;
    // reference to Traits
    ITraits public traits;
    // reference to Seed
    ISeed public randomSource;

    /**
     * instantiates contract and rarity tables
     */

    constructor(
        address _gem,
        address _traits,
        uint256 _maxTokens
    ) ERC721("Yield Hunt", "HGAME") {
        AdminWallet = payable(0x9F523A9d191704887Cf667b86d3B6Cd6eBE9D6e9);
        Multisig = payable(0x49208f9eEAD9416446cdE53435C6271A0235dDA4);
        gem = IGEM(_gem);
        traits = ITraits(_traits);
        MAX_TOKENS = _maxTokens;
        PAID_TOKENS = _maxTokens / 5;
    }

    function setTraits(address _traits) external onlyOwner {
        traits = ITraits(_traits);
    }

    /** EXTERNAL */
    function setTimeforPremint(uint256 _startTimestamp, uint256 _endTimestamp)
        external
        onlyOwner
    {
        startTimestamp = _startTimestamp;
        endTimestamp = _endTimestamp;
    }

    modifier onlyWhileOpen() {
        require(
            block.timestamp >= startTimestamp && block.timestamp <= endTimestamp
        );
        _;
    }

    modifier onlyWhileClose() {
        require(block.timestamp > endTimestamp);
        _;
    }

    function isOpened() public view returns (bool) {
        return
            block.timestamp >= startTimestamp &&
            block.timestamp <= endTimestamp;
    }

    function isClosed() public view returns (bool) {
        return block.timestamp > endTimestamp;
    }

    function setWhitelist(address[] memory _whitelist) external onlyOwner {
        for (uint256 i = 0; i < _whitelist.length; i++) {
            WhiteList[_whitelist[i]] = true;
        }
    }

    /*
     * mint a token - 90% Adventurers, 10% Hunters
     * The first 20% are free to claim, the remaining cost $GEM
     */
    function mint(uint256 amount, bool stake) external payable whenNotPaused {
        require(minted + amount <= MAX_TOKENS, "All tokens minted");
        require(amount > 0, "Invalid mint amount");
        if (isOpened()) {
            _premint(amount, stake);
        } else if (isClosed()) {
            _normal_mint(amount, stake);
        }
    }

    // after white list period
    function _normal_mint(uint256 amount, bool stake) private onlyWhileClose {
        //MAYBE WHITELISTED CAN MINT 1.25
        require(tx.origin == _msgSender(), "Only EOA");
        if (minted < PAID_TOKENS) {
            require(
                minted + amount <= PAID_TOKENS,
                "All tokens on-sale already sold"
            );

            require(
                amount * MINT_PRICE <= msg.value || _msgSender() == AdminWallet,
                "Invalid payment amount"
            );
        } else {
            require(
                msg.value == 0,
                "Do not send AVAX, minting is with GEM now"
            );
        }

        core_mint(amount, stake);
    }

    // during white list period
    function _premint(uint256 amount, bool stake) private onlyWhileOpen {
        require(tx.origin == _msgSender(), "Only EOA");
        require(WhiteList[_msgSender()], "You are not whitelisted");
        require(
            whiteListMintCounts[_msgSender()] + amount <= 5,
            "White list can only mint 5"
        );
        require(
            minted + amount <= PAID_TOKENS,
            "All tokens on-sale already sold"
        );

        require(
            amount * WL_PRICE <= msg.value || _msgSender() == AdminWallet,
            "Invalid payment amount"
        );
        whiteListMintCounts[_msgSender()] += amount;
        core_mint(amount, stake);
    }

    function core_mint(uint256 amount, bool stake) private {
        uint256 totalGemCost = 0;
        uint16[] memory tokenIds = stake
            ? new uint16[](amount)
            : new uint16[](0);
        uint256 seed;
        for (uint256 i = 0; i < amount; i++) {
            minted++;
            seed = random(minted);
            generate(minted, seed);
            address recipient = selectRecipient(seed);
            if (!stake || recipient != _msgSender()) {
                _safeMint(recipient, minted);
            } else {
                _safeMint(address(barn), minted);
                tokenIds[i] = minted;
            }
            if (tokenTraits[minted].isAdventurer) {
                Adventurer_minted += 1;
            } else {
                Hunter_minted += 1;
            }
            totalGemCost += mintCost(minted); // 0 if we are before 10.000
        }

        //we may want to do that first but w/o reentrancy
        if (totalGemCost > 0) gem.burn(_msgSender(), totalGemCost);
        if (stake) barn.addManyToBarnAndPack(_msgSender(), tokenIds);
        withdrawMoneyTo(Multisig); //hihi
    }

    /**
     * the first 20% are paid in AVAX
     * the next 20% are 20000 $GEM
     * the next 40% are 40000 $GEM
     * the final 20% are 80000 $GEM
     * @param tokenId the ID to check the cost of to mint
     * @return the cost of the given token ID
     */
    function mintCost(uint256 tokenId) public view returns (uint256) {
        if (tokenId <= PAID_TOKENS) return 0;
        if (tokenId <= (MAX_TOKENS * 2) / 5) return 20000 ether;
        if (tokenId <= (MAX_TOKENS * 4) / 5) return 40000 ether;
        return 80000 ether;
    }

    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        // Hardcode the Barn's approval so that users don't have to waste gas approving
        if (_msgSender() != address(barn))
            require(
                _isApprovedOrOwner(_msgSender(), tokenId),
                "ERC721: transfer caller is not owner nor approved"
            );
        _transfer(from, to, tokenId);
    }

    /** INTERNAL */

    /**
     * generates traits for a specific token, checking to make sure it's unique
     * @param tokenId the id of the token to generate traits for
     * @param seed a pseudorandom 256 bit number to derive traits from
     * @return t - a struct of traits for the given token ID
     */
    function generate(uint256 tokenId, uint256 seed)
        internal
        returns (AvtHtr memory t)
    {
        t = selectTraits(seed);
        tokenTraits[tokenId] = t;

        return t;
    }

    /**
     * uses A.J. Walker's Alias algorithm for O(1) rarity table lookup
     * ensuring O(1) instead of O(n) reduces mint cost by more than 50%
     * probability & alias tables are generated off-chain beforehand
     * @param seed portion of the 256 bit seed to remove trait correlation
     * @param traitType the trait type to select a trait for
     * @return the ID of the randomly selected trait
     */
    function selectTrait(uint16 seed, uint8 traitType)
        internal
        view
        returns (uint8)
    {
        return traits.selectTrait(seed, traitType);
    }

    /**
     * the first 20% (AVAX purchases) go to the minter
     * the remaining 80% have a 10% chance to be given to a random staked adventurer
     * @param seed a random value to select a recipient from
     * @return the address of the recipient (either the minter or the adventurer thief's owner)
     */
    function selectRecipient(uint256 seed) internal view returns (address) {
        if (minted <= PAID_TOKENS || ((seed >> 245) % 10) != 0)
            return _msgSender(); // top 10 bits haven't been used
        address thief = barn.randomHunterOwner(seed >> 144); // 144 bits reserved for trait selection
        if (thief == address(0x0)) return _msgSender();
        return thief;
    }

    /**
     * selects the species and all of its traits based on the seed value
     * @param _seed a pseudorandom 256 bit number to derive traits from
     * @return t -  a struct of randomly selected traits
     */
    function selectTraits(uint256 _seed)
        internal
        view
        returns (AvtHtr memory t)
    {
        uint256 seed = _seed;
        t.isAdventurer = (seed & 0xFFFF) % 10 != 0;
        if (t.isAdventurer) {
            seed >>= 16;
            t.jacket = selectTrait(uint16(seed & 0xFFFF), 0);
            seed >>= 16;
            t.hair = selectTrait(uint16(seed & 0xFFFF), 1);
            seed >>= 16;
            t.backpack = selectTrait(uint16(seed & 0xFFFF), 2);
        } else {
            seed >>= 16;
            t.arm = selectTrait(uint16(seed & 0xFFFF), 3);
            seed >>= 16;
            t.clothes = selectTrait(uint16(seed & 0xFFFF), 4);
            seed >>= 16;
            t.mask = selectTrait(uint16(seed & 0xFFFF), 5);
            seed >>= 16;
            t.weapon = selectTrait(uint16(seed & 0xFFFF), 6);
            seed >>= 16;
            t.alphaIndex = selectTrait(uint16(seed & 0xFFFF), 7);
        }
    }

    /**
     * generates a pseudorandom number
     * @param seed a value ensure different outcomes for different sources in the same block
     * @return a pseudorandom value
     */

    // need to use seed contract
    function random(uint256 seed) internal returns (uint256) {
        return
            uint256(
                keccak256(
                    abi.encodePacked(
                        msg.sender,
                        blockhash(block.number - 1),
                        block.timestamp,
                        seed
                    )
                )
            ) ^ randomSource.getRandomSeed(seed);
    }

    /** READ */

    function getTokenTraits(uint256 tokenId)
        external
        view
        override
        returns (AvtHtr memory)
    {
        return tokenTraits[tokenId];
    }

    function getPaidTokens() external view override returns (uint256) {
        return PAID_TOKENS;
    }

    /** ADMIN */

    /**
     * called after deployment so that the contract can get random adventurers thieves
     * @param _barn the address of the Barn
     */
    function setBarn(address _barn) external onlyOwner {
        barn = IBarn(_barn);
    }

    function setRandomSource(address _randomSource) external onlyOwner {
        randomSource = ISeed(_randomSource);
    }

    /**
     * allows owner to withdraw funds from minting
     */
    function getBalance() public view returns (uint256) {
        return address(this).balance;
    }

    function withdrawMoneyTo(address payable _to) internal {
        _to.call{value: getBalance(), gas: 100000}("");
    }

    function withdraw() external onlyOwner {
        payable(owner()).transfer(address(this).balance);
    }

    /**
     * updates the number of tokens for sale
     */
    function setPaidTokens(uint256 _paidTokens) external onlyOwner {
        PAID_TOKENS = _paidTokens;
    }

    /**
     * enables owner to pause / unpause minting
     */
    function setPaused(bool _paused) external onlyOwner {
        if (_paused) _pause();
        else _unpause();
    }

    /** RENDER */

    function tokenURI(uint256 tokenId)
        public
        view
        override
        returns (string memory)
    {
        require(
            _exists(tokenId),
            "ERC721Metadata: URI query for nonexistent token"
        );
        return traits.tokenURI(tokenId);
    }
}

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

interface IBarn {
    function addManyToBarnAndPack(address account, uint16[] memory tokenIds)
        external;

    function randomHunterOwner(uint256 seed) external view returns (address);
}

// SPDX-License-Identifier: MIT LICENSE

pragma solidity ^0.8.0;

interface IGEM  {
    function burn(address from, uint256 amount) external;
}

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

interface IHunter {
    // struct to store each token's traits
    struct AvtHtr {
        bool isAdventurer;
        uint8 jacket;
        uint8 hair;
        uint8 backpack;
        uint8 arm;
        uint8 clothes;
        uint8 mask;
        uint8 weapon;
        uint8 alphaIndex;
    }

    function getPaidTokens() external view returns (uint256);

    function getTokenTraits(uint256 tokenId)
        external
        view
        returns (AvtHtr memory);
}

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

interface ISeed {
    function getRandomSeed(uint256) external returns(uint256);
}

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

interface ITraits {
    function tokenURI(uint256 tokenId) external view returns (string memory);

    function selectTrait(uint16 seed, uint8 traitType)
        external
        view
        returns (uint8);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 
/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length)
        internal
        pure
        returns (string memory)
    {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./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() {
        _setOwner(_msgSender());
    }

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

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

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

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

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

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

import "./Context.sol";
/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}

[{"inputs":[{"internalType":"address","name":"_hunter","type":"address"},{"internalType":"address","name":"_gem","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"earned","type":"uint256"},{"indexed":false,"internalType":"bool","name":"unstaked","type":"bool"}],"name":"AdventurerClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"earned","type":"uint256"},{"indexed":false,"internalType":"bool","name":"unstaked","type":"bool"}],"name":"HunterClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"TokenStaked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"CLAIMING_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DAILY_GEM_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"GEM_CLAIM_TAX_PERCENTAGE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAXIMUM_GLOBAL_GEM","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_ALPHA","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINIMUM_TO_EXIT","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint16[]","name":"tokenIds","type":"uint16[]"}],"name":"addManyToBarnAndPack","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"barn","outputs":[{"internalType":"uint16","name":"tokenId","type":"uint16"},{"internalType":"uint80","name":"value","type":"uint80"},{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"calculateRewards","outputs":[{"internalType":"uint256","name":"owed","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint16[]","name":"tokenIds","type":"uint16[]"},{"internalType":"bool","name":"unstake","type":"bool"}],"name":"claimManyFromBarnAndPack","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"gemPerAlpha","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"isAdventurer","outputs":[{"internalType":"bool","name":"adventurer","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastClaimTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"from","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"pack","outputs":[{"internalType":"uint16","name":"tokenId","type":"uint16"},{"internalType":"uint80","name":"value","type":"uint80"},{"internalType":"address","name":"owner","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"packIndices","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"seed","type":"uint256"}],"name":"randomHunterOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"rescue","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rescueEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newfee","type":"uint256"}],"name":"setClaimingFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_MAXIMUM_GLOBAL_GEM","type":"uint256"}],"name":"setMAXIMUM_GLOBAL_GEM","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_paused","type":"bool"}],"name":"setPaused","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_enabled","type":"bool"}],"name":"setRescueEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAdventurerStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAlphaStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalGemEarned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unaccountedRewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000eab33f781ada4ee7e91fd63ad87c5bb47ffb8a830000000000000000000000004d3ddeec55f148b3f8765a2abc00252834ed7e62

-----Decoded View---------------
Arg [0] : _hunter (address): 0xeab33f781ada4ee7e91fd63ad87c5bb47ffb8a83
Arg [1] : _gem (address): 0x4d3ddeec55f148b3f8765a2abc00252834ed7e62

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 000000000000000000000000eab33f781ada4ee7e91fd63ad87c5bb47ffb8a83
Arg [1] : 0000000000000000000000004d3ddeec55f148b3f8765a2abc00252834ed7e62

192:17414:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5856:702;;;;;;:::i;:::-;;:::i;:::-;;17186:303;;;;;;;;;;-1:-1:-1;17186:303:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;;9345:33:14;;;9327:52;;9315:2;9300:18;17186:303:0;;;;;;;;14661:118;;;;;;;;;;-1:-1:-1;14661:118:0;;;;;:::i;:::-;;:::i;15807:778::-;;;;;;;;;;-1:-1:-1;15807:778:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;7366:32:14;;;7348:51;;7336:2;7321:18;15807:778:0;7202:203:14;292:35:0;;;;;;;;;;;;326:1;292:35;;;;;15358:4:14;15346:17;;;15328:36;;15316:2;15301:18;292:35:0;15186:184:14;1385:30:0;;;;;;;;;;;;;;;;;;;14474:25:14;;;14462:2;14447:18;1385:30:0;14328:177:14;1609:48:0;;;;;;;;;;;;1651:6;1609:48;;905:37;;;;;;;;;;-1:-1:-1;905:37:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;905:37:0;;-1:-1:-1;;;905:37:0;;-1:-1:-1;;;;;905:37:0;;;;;;;14168:6:14;14156:19;;;14138:38;;-1:-1:-1;;;;;14212:35:14;;;14207:2;14192:18;;14185:63;-1:-1:-1;;;;;14284:32:14;14264:18;;;14257:60;14126:2;14111:18;905:37:0;13940:383:14;2310:33:0;;;;;;;;;;-1:-1:-1;2310:33:0;;;;;;;;;;;9156:14:14;;9149:22;9131:41;;9119:2;9104:18;2310:33:0;8991:187:14;17497:106:0;;;;;;;;;;;;;:::i;1715:53::-;;;;;;;;;;;;1766:2;1715:53;;2787:101;;;;;;;;;;-1:-1:-1;2787:101:0;;;;;:::i;:::-;;:::i;1068:86:13:-;;;;;;;;;;-1:-1:-1;1115:4:13;1139:7;-1:-1:-1;;;1139:7:13;;;;1068:86;;2188:33:0;;;;;;;;;;;;;;;;2022:29;;;;;;;;;;;;;;;;11529:1777;;;;;;;;;;-1:-1:-1;11529:1777:0;;;;;:::i;:::-;;:::i;1098:46::-;;;;;;;;;;-1:-1:-1;1098:46:0;;;;;:::i;:::-;;;;;;;;;;;;;;1185:35;;;;;;;;;;;;;;;;1671:94:12;;;;;;;;;;;;;:::i;14483:103:0:-;;;;;;;;;;-1:-1:-1;14483:103:0;;;;;:::i;:::-;;:::i;2106:36::-;;;;;;;;;;;;;;;;3113:1004;;;;;;;;;;-1:-1:-1;3113:1004:0;;;;;:::i;:::-;;:::i;1020:87:12:-;;;;;;;;;;-1:-1:-1;1066:7:12;1093:6;-1:-1:-1;;;;;1093:6:12;1020:87;;14991:186:0;;;;;;;;;;-1:-1:-1;14991:186:0;;;;;:::i;:::-;;:::i;1936:40::-;;;;;;;;;;;;;;;;2598:161;;;;;;;;;;-1:-1:-1;2598:161:0;;;;;:::i;:::-;;:::i;1286:37::-;;;;;;;;;;;;;;;;1467:52;;;;;;;;;;;;1508:11;1467:52;;6566:969;;;;;;;;;;-1:-1:-1;6566:969:0;;;;;:::i;:::-;;:::i;1005:39::-;;;;;;;;;;-1:-1:-1;1005:39:0;;;;;:::i;:::-;;:::i;1857:52::-;;;;;;;;;;;;;;;;1920:229:12;;;;;;;;;;-1:-1:-1;1920:229:12;;;;;:::i;:::-;;:::i;5856:702:0:-;1115:4:13;1139:7;-1:-1:-1;;;1139:7:13;;;;1393:9;1385:38;;;;-1:-1:-1;;;1385:38:13;;;;;;;:::i;:::-;;;;;;;;;14024:18:0::1;;14007:14;;:35;14003:303;;;14237:6;1508:11;14157:21;;14114:18;;14096:15;:36;;;;:::i;:::-;14095:83;;;;:::i;:::-;:121;;;;:::i;:::-;14094:149;;;;:::i;:::-;14059:14;;:184;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;14279:15:0::1;14258:18;:36:::0;14003:303:::1;6114:12:::2;;6096:8;:15;:30;;;;:::i;:::-;6083:9;:43;;6061:110;;;::::0;-1:-1:-1;;;6061:110:0;;12140:2:14;6061:110:0::2;::::0;::::2;12122:21:14::0;12179:2;12159:18;;;12152:30;-1:-1:-1;;;12198:18:14;;;12191:47;12255:18;;6061:110:0::2;11938:341:14::0;6061:110:0::2;6182:12;6214:9:::0;6209:245:::2;6233:8;:15;6229:1;:19;6209:245;;;6274:25;6287:8;6296:1;6287:11;;;;;;;;:::i;:::-;;;;;;;6274:25;;:12;:25::i;:::-;6270:172;;;6326:46;6351:8;6360:1;6351:11;;;;;;;;:::i;:::-;;;;;;;6326:46;;6364:7;6326:24;:46::i;:::-;6318:54;::::0;;::::2;:::i;:::-;;;6270:172;;;6400:42;6421:8;6430:1;6421:11;;;;;;;;:::i;:::-;;;;;;;6400:42;;6434:7;6400:20;:42::i;:::-;6392:50;::::0;;::::2;:::i;:::-;;;6270:172;6250:3:::0;::::2;::::0;::::2;:::i;:::-;;;;6209:245;;;-1:-1:-1::0;6494:9:0;6490:22:::2;;6505:7;5856:702:::0;;:::o;6490:22::-:2;6522:3;::::0;-1:-1:-1;;;;;6522:3:0::2;:8;680:10:1::0;6522:28:0::2;::::0;-1:-1:-1;;;;;;6522:28:0::2;::::0;;;;;;-1:-1:-1;;;;;8554:32:14;;;6522:28:0::2;::::0;::::2;8536:51:14::0;8603:18;;;8596:34;;;8509:18;;6522:28:0::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;6018:540;5856:702:::0;;:::o;17186:303::-;17335:6;-1:-1:-1;;;;;17362:20:0;;;17354:68;;;;-1:-1:-1;;;17354:68:0;;11044:2:14;17354:68:0;;;11026:21:14;11083:2;11063:18;;;11056:30;11122:34;11102:18;;;11095:62;-1:-1:-1;;;11173:18:14;;;11166:33;11216:19;;17354:68:0;10842:399:14;17354:68:0;-1:-1:-1;;;;17186:303:0;;;;;;;:::o;14661:118::-;1066:7:12;1093:6;-1:-1:-1;;;;;1093:6:12;680:10:1;1240:23:12;1232:68;;;;-1:-1:-1;;;1232:68:12;;;;;;;:::i;:::-;14728:7:0::1;14724:47;;;14737:8;:6;:8::i;:::-;14661:118:::0;:::o;14724:47::-:1;14761:10;:8;:10::i;15807:778::-:0;15871:7;15895:16;;15915:1;15895:21;15891:46;;;-1:-1:-1;15933:3:0;;15807:778;-1:-1:-1;15807:778:0:o;15891:46::-;15948:14;15987:16;;15966:4;15973:10;15966:17;15965:38;;;;:::i;:::-;16099:2;16090:11;;;;;15948:55;-1:-1:-1;16061:18:0;;16203:13;16215:1;326;16203:13;:::i;:::-;16191:25;;;;16186:362;326:1;16218:14;;16186:362;;16268:7;;;;:4;:7;;;;;:14;:18;;16285:1;;16268:18;:::i;:::-;16254:32;;;;:::i;:::-;;;16385:10;16375:6;:20;16371:34;;16397:8;;16371:34;16500:7;;;;:4;:7;;;;;16515:14;;16508:21;;:4;:21;:::i;:::-;16500:30;;;;;;;;:::i;:::-;;;;;;;;;;:36;-1:-1:-1;;;16500:36:0;;-1:-1:-1;;;;;16500:36:0;;;-1:-1:-1;;;;;15807:778:0:o;16186:362::-;16234:3;;;;:::i;:::-;;;;16186:362;;;-1:-1:-1;16573:3:0;;15807:778;-1:-1:-1;;;;15807:778:0:o;17497:106::-;1066:7:12;1093:6;-1:-1:-1;;;;;1093:6:12;680:10:1;1240:23:12;1232:68;;;;-1:-1:-1;;;1232:68:12;;;;;;;:::i;:::-;1066:7;1093:6;;17547:48:0::1;::::0;-1:-1:-1;;;;;1093:6:12;;;;17573:21:0::1;17547:48:::0;::::1;;;::::0;17573:21;;17547:48;1066:7:12;17547:48:0;17573:21;1093:6:12;17547:48:0;::::1;;;;;;;;;;;;;::::0;::::1;;;;2787:101:::0;1066:7:12;1093:6;-1:-1:-1;;;;;1093:6:12;680:10:1;1240:23:12;1232:68;;;;-1:-1:-1;;;1232:68:12;;;;;;;:::i;:::-;2858:12:0::1;:22:::0;2787:101::o;11529:1777::-;11602:13;;;;11594:41;;;;-1:-1:-1;;;11594:41:0;;10700:2:14;11594:41:0;;;10682:21:14;10739:2;10719:18;;;10712:30;-1:-1:-1;;;10758:18:14;;;10751:45;10813:18;;11594:41:0;10498:339:14;11594:41:0;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11758:1541:0;11778:19;;;11758:1541;;;11829:8;;11838:1;11829:11;;;;;;;:::i;:::-;;;;;;;11819:21;;11859;11872:7;11859:12;:21::i;:::-;11855:1433;;;11909:13;;;;:4;:13;;;;;;;;;11901:21;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;11901:21:0;;;;;;;;-1:-1:-1;;;11901:21:0;;;-1:-1:-1;;;;;11901:21:0;;;;;;;;-1:-1:-1;680:10:1;11949:27:0;11941:58;;;;-1:-1:-1;;;11941:58:0;;;;;;;:::i;:::-;12018:6;;-1:-1:-1;;;;;12018:6:0;:23;12072:4;680:10:1;12135:7:0;12018:168;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;12236:13:0;;;;:4;:13;;;;;12229:20;;;;12268:26;;12229:20;;-1:-1:-1;12229:20:0;;12236:13;12268:26;;12229:20;;12268:26;:::i;:::-;;;;-1:-1:-1;;12318:35:0;;;14714:25:14;;;12345:1:0;14770:2:14;14755:18;;14748:34;12348:4:0;14798:18:14;;;14791:50;12318:35:0;;;;;;;14702:2:14;12318:35:0;;;11855:1433;;;12402:24;12418:7;12402:15;:24::i;:::-;12394:32;;12453:11;;;;:4;:11;;;;;;;;12465:20;;;:11;:20;;;;;;;12453:33;;12394:32;;-1:-1:-1;12453:11:0;;:33;;;;;;:::i;:::-;;;;;;;;;;12445:41;;;;;;;;12453:33;;;;12445:41;;;;;;;;;-1:-1:-1;;;;;12445:41:0;;;;;;;;-1:-1:-1;;;12445:41:0;;;-1:-1:-1;;;;;12445:41:0;;;;;;;;-1:-1:-1;680:10:1;12513:27:0;12505:58;;;;-1:-1:-1;;;12505:58:0;;;;;;;:::i;:::-;12602:5;12582:16;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;;12660:6:0;;-1:-1:-1;;;;;12660:6:0;:23;12714:4;680:10:1;12777:7:0;12660:168;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;12879:11:0;;;;:4;:11;;;;;12891:18;;12879:11;;-1:-1:-1;12891:22:0;;12912:1;;12891:22;:::i;:::-;12879:35;;;;;;;;:::i;:::-;;;;;;;;;12867:47;;;;;;;;12879:35;;;;12867:47;;;;;;;;;-1:-1:-1;;;;;12867:47:0;;;;;-1:-1:-1;;;12867:47:0;;-1:-1:-1;;;;;12867:47:0;;;;;12933:11;;;:4;:11;;;;;12945:20;;;:11;:20;;;;;;;12933:33;;12867:47;;-1:-1:-1;12867:47:0;;12933:11;:33;;;;;;:::i;:::-;;;;;;;;;:45;;:33;;:45;;;;;;;;;;;-1:-1:-1;;;;;12933:45:0;-1:-1:-1;;;12933:45:0;-1:-1:-1;;;;;;;;;;12933:45:0;;;;;-1:-1:-1;;;;;;12933:45:0;;;;;;;;;;;;;;;;13073:20;;;:11;:20;;;;;;13052:17;;13040:30;;;;;;;;:53;;;;13112:11;;;:4;:11;;;:17;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;13112:17:0;;;;;;;;;;;;;13175:20;;;:11;:20;;;;;;13168:27;;;13241:31;;14714:25:14;;;14755:18;;;14748:34;;;;13112:17:0;14798:18:14;;;14791:50;13241:31:0;;;;;;;14702:2:14;13241:31:0;;;11855:1433;11799:3;;;;:::i;:::-;;;;11758:1541;;1671:94:12;1066:7;1093:6;-1:-1:-1;;;;;1093:6:12;680:10:1;1240:23:12;1232:68;;;;-1:-1:-1;;;1232:68:12;;;;;;;:::i;:::-;1736:21:::1;1754:1;1736:9;:21::i;:::-;1671:94::o:0;14483:103:0:-;1066:7:12;1093:6;-1:-1:-1;;;;;1093:6:12;680:10:1;1240:23:12;1232:68;;;;-1:-1:-1;;;1232:68:12;;;;;;;:::i;:::-;14554:13:0::1;:24:::0;;-1:-1:-1;;14554:24:0::1;::::0;::::1;;::::0;;;::::1;::::0;;14483:103::o;3113:1004::-;-1:-1:-1;;;;;3243:23:0;;680:10:1;3243:23:0;:47;;;;-1:-1:-1;;;;;;3270:20:0;;3281:9;3270:20;3243:47;3242:101;;;-1:-1:-1;3336:6:0;;-1:-1:-1;;;;;3336:6:0;680:10:1;-1:-1:-1;;;;;3312:31:0;;3242:101;3220:177;;;;-1:-1:-1;;;3220:177:0;;12847:2:14;3220:177:0;;;12829:21:14;12886:2;12866:18;;;12859:30;12925:28;12905:18;;;12898:56;12971:18;;3220:177:0;12645:350:14;3220:177:0;3413:9;3408:702;3432:8;:15;3428:1;:19;3408:702;;;3497:6;;-1:-1:-1;;;;;3497:6:0;680:10:1;-1:-1:-1;;;;;3473:31:0;;3469:465;;3615:6;;3630:11;;680:10:1;;-1:-1:-1;;;;;3615:6:0;;:14;;3630:8;;3639:1;;3630:11;;;;;;:::i;:::-;;;;;;;3615:27;;;;;;;;;;;;;;13921:6:14;13909:19;;;;13891:38;;13879:2;13864:18;;13746:189;3615:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;3615:43:0;;3585:130;;;;-1:-1:-1;;;3585:130:0;;13606:2:14;3585:130:0;;;13588:21:14;13645:2;13625:18;;;13618:30;-1:-1:-1;;;13664:18:14;;;13657:43;13717:18;;3585:130:0;13404:337:14;3585:130:0;3734:6;;-1:-1:-1;;;;;3734:6:0;:19;680:10:1;3776:4:0;3783:8;3792:1;3783:11;;;;;;;;:::i;:::-;;;;;;;;;;;3734:61;;-1:-1:-1;;;;;;3734:61:0;;;;;;;-1:-1:-1;;;;;7667:15:14;;;3734:61:0;;;7649:34:14;7719:15;;;;7699:18;;;7692:43;7783:6;7771:19;7751:18;;;7744:47;7584:18;;3734:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3469:465;;;3821:8;3830:1;3821:11;;;;;;;;:::i;:::-;;;;;;;:16;;3836:1;3821:16;3817:117;;;3858:8;;3817:117;3954:25;3967:8;3976:1;3967:11;;;;;;;;:::i;3954:25::-;3950:148;;;3998:42;4019:7;4028:8;4037:1;4028:11;;;;;;;;:::i;:::-;;;;;;;3998:42;;:20;:42::i;:::-;3950:148;;;4060:38;4077:7;4086:8;4095:1;4086:11;;;;;;;;:::i;:::-;;;;;;;4060:38;;:16;:38::i;:::-;3449:3;;;;:::i;:::-;;;;3408:702;;;;3113:1004;;:::o;14991:186::-;15142:6;;:27;;-1:-1:-1;;;15142:27:0;;;;;14474:25:14;;;15078:15:0;;-1:-1:-1;;;;;15142:6:0;;:18;;14447::14;;15142:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;15111:58:0;;14991:186;-1:-1:-1;;;;;;;;;14991:186:0:o;2598:161::-;1066:7:12;1093:6;-1:-1:-1;;;;;1093:6:12;680:10:1;1240:23:12;1232:68;;;;-1:-1:-1;;;1232:68:12;;;;;;;:::i;:::-;2711:18:0::1;:40:::0;2598:161::o;6566:969::-;6693:6;;:30;;-1:-1:-1;;;6693:30:0;;;;;14474:25:14;;;6659:12:0;;-1:-1:-1;;;;;6693:6:0;;:21;;14447:18:14;;6693:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:43;6689:839;;;6753:18;6774:13;;;:4;:13;;;;;;;;;6753:34;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;6753:34:0;;;;;;;;-1:-1:-1;;;6753:34:0;;;-1:-1:-1;;;;;6753:34:0;;;;;;;;6823:18;;6806:14;;:35;6802:514;;;6964:6;1508:11;6910:5;:11;;;-1:-1:-1;;;;;6892:29:0;:15;:29;;;;:::i;:::-;6891:48;;;;:::i;:::-;6890:80;;;;:::i;:::-;6862:108;;6802:514;;;7010:18;;6996:5;:11;;;-1:-1:-1;;;;;6996:32:0;;6992:324;;;7056:1;7049:8;;6992:324;;;7238:6;1508:11;7184:5;:11;;;-1:-1:-1;;;;;7163:32:0;:18;;:32;;;;:::i;:::-;7162:51;;;;:::i;:::-;7161:83;;;;:::i;:::-;7133:111;;6992:324;6738:589;6566:969;;;:::o;6689:839::-;7348:13;7364:24;7380:7;7364:15;:24::i;:::-;7348:40;;7403:18;7424:11;;;:4;:11;;;;;;;;7436:20;;;:11;:20;;;;;;7424:33;;7348:40;;-1:-1:-1;7403:18:0;;7424:11;;7436:20;7424:33;;;;;;:::i;:::-;;;;;;;;;;7403:54;;;;;;;;7424:33;;;;7403:54;;;;;;;;;-1:-1:-1;;;;;7403:54:0;;;;;;;-1:-1:-1;;;7403:54:0;;-1:-1:-1;;;;;7403:54:0;;;;;7490:11;;7403:54;;-1:-1:-1;7490:25:0;;7403:54;7490:25;:::i;:::-;7479:37;;7480:5;7479:37;:::i;:::-;7472:44;;7333:195;;6689:839;6566:969;;;:::o;1005:39::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1005:39:0;;;-1:-1:-1;;;;;1005:39:0;;-1:-1:-1;;;;1005:39:0;;-1:-1:-1;;;;;1005:39:0;;:::o;1920:229:12:-;1066:7;1093:6;-1:-1:-1;;;;;1093:6:12;680:10:1;1240:23:12;1232:68;;;;-1:-1:-1;;;1232:68:12;;;;;;;:::i;:::-;-1:-1:-1;;;;;2023:22:12;::::1;2001:110;;;::::0;-1:-1:-1;;;2001:110:12;;10293:2:14;2001:110:12::1;::::0;::::1;10275:21:14::0;10332:2;10312:18;;;10305:30;10371:34;10351:18;;;10344:62;-1:-1:-1;;;10422:18:14;;;10415:36;10468:19;;2001:110:12::1;10091:402:14::0;2001:110:12::1;2122:19;2132:8;2122:9;:19::i;7950:1724:0:-:0;8051:12;8102:13;;;:4;:13;;;;;;;;8081:34;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8081:34:0;;;;;;;;-1:-1:-1;;;8081:34:0;;;-1:-1:-1;;;;;8081:34:0;;;;;;;680:10:1;8134:27:0;8126:58;;;;-1:-1:-1;;;8126:58:0;;;;;;;:::i;:::-;8219:7;:58;;;;;1651:6;8248:5;:11;;;-1:-1:-1;;;;;8230:29:0;:15;:29;;;;:::i;:::-;:47;8219:58;8217:61;8195:146;;;;-1:-1:-1;;;8195:146:0;;13202:2:14;8195:146:0;;;13184:21:14;13241:2;13221:18;;;13214:30;13280:34;13260:18;;;13253:62;-1:-1:-1;;;13331:18:14;;;13324:33;13374:19;;8195:146:0;13000:399:14;8195:146:0;8373:18;;8356:14;;:35;8352:440;;;8468:6;1508:11;8435:5;:11;;;-1:-1:-1;;;;;8417:29:0;:15;:29;;;;:::i;:::-;8416:48;;;;:::i;:::-;8415:59;;;;:::i;:::-;8408:66;;8352:440;;;8510:18;;8496:5;:11;;;-1:-1:-1;;;;;8496:32:0;;8492:300;;;8552:1;8545:8;;8492:300;;;8718:6;1508:11;8668:5;:11;;;-1:-1:-1;;;;;8647:32:0;:18;;:32;;;;:::i;:::-;8646:51;;;;:::i;:::-;8645:79;;;;:::i;:::-;8621:103;;8492:300;8806:7;8802:808;;;8834:15;8841:7;8834:6;:15::i;:::-;8852:1;8834:19;8857:1;8834:24;8830:161;;;8929:19;8943:4;8929:13;:19::i;:::-;8974:1;8967:8;;8830:161;9005:6;;-1:-1:-1;;;;;9005:6:0;:23;9037:4;680:10:1;9058:7:0;9005:65;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;9116:13:0;;;;:4;:13;;;;;9109:20;;;;9144:26;;9109:20;;-1:-1:-1;9109:20:0;;9116:13;9144:26;;9109:20;;9144:26;:::i;:::-;;;;-1:-1:-1;8802:808:0;;-1:-1:-1;8802:808:0;;9203:54;9253:3;9218:31;1766:2;9218:4;:31;:::i;:::-;9217:39;;;;:::i;:::-;9203:13;:54::i;:::-;9359:3;9324:30;1766:2;9359:3;9324:30;:::i;:::-;9316:39;;:4;:39;:::i;:::-;9315:47;;;;:::i;:::-;9308:54;;9431:152;;;;;;;;9510:7;9431:152;;;;;;9551:15;-1:-1:-1;;;;;9431:152:0;;;;;9463:12;680:10:1;;600:98;9463:12:0;-1:-1:-1;;;;;9431:152:0;;;;;;9415:13;;;;:4;:13;;;;;;;;;:168;;;;;;;;;;;;;;;;-1:-1:-1;;;9415:168:0;-1:-1:-1;;;;;;;;;;9415:168:0;;;;;-1:-1:-1;;;;;;9415:168:0;;;;;;;;;;;;;;;;;;;;;;8802:808;9625:41;;;14714:25:14;;;14770:2;14755:18;;14748:34;;;14825:14;;14818:22;14798:18;;;14791:50;9625:41:0;;;;;;;14702:2:14;9625:41:0;;;8070:1604;7950:1724;;;;:::o;10011:1390::-;10160:6;;:23;;-1:-1:-1;;;10160:23:0;;;;;14474:25:14;;;10108:12:0;;10195:4;;-1:-1:-1;;;;;10160:6:0;;;;:14;;14447:18:14;;10160:23:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;10160:40:0;;10138:113;;;;-1:-1:-1;;;10138:113:0;;9941:2:14;10138:113:0;;;9923:21:14;9980:2;9960:18;;;9953:30;10019:25;9999:18;;;9992:53;10062:18;;10138:113:0;9739:347:14;10138:113:0;10262:13;10278:24;10294:7;10278:15;:24::i;:::-;10262:40;;10313:18;10334:11;;;:4;:11;;;;;;;;10346:20;;;:11;:20;;;;;;10334:33;;10262:40;;-1:-1:-1;10313:18:0;;10334:11;;10346:20;10334:33;;;;;;:::i;:::-;;;;;;;;;;10313:54;;;;;;;;10334:33;;;;10313:54;;;;;;;;;-1:-1:-1;;;;;10313:54:0;;;;;;;;-1:-1:-1;;;10313:54:0;;;-1:-1:-1;;;;;10313:54:0;;;;;;;;-1:-1:-1;680:10:1;10386:27:0;10378:58;;;;-1:-1:-1;;;10378:58:0;;;;;;;:::i;:::-;10479:5;:11;;;-1:-1:-1;;;;;10465:25:0;:11;;:25;;;;:::i;:::-;10454:37;;10455:5;10454:37;:::i;:::-;10447:44;;10552:7;10548:793;;;10596:5;10576:16;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;;10650:6:0;;-1:-1:-1;;;;;10650:6:0;:23;10682:4;680:10:1;10703:7:0;10650:65;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;10750:22:0;10775:11;;;:4;:11;;;;;10787:18;;10750:22;;-1:-1:-1;10775:11:0;10787:22;;10808:1;;10787:22;:::i;:::-;10775:35;;;;;;;;:::i;:::-;;;;;;;;;10750:60;;;;;;;;10775:35;;;;10750:60;;;;;;;;;-1:-1:-1;;;;;10750:60:0;;;;;-1:-1:-1;;;10750:60:0;;-1:-1:-1;;;;;10750:60:0;;;;;10825:11;;;:4;:11;;;;;10837:20;;;:11;:20;;;;;;;10825:33;;10750:60;;-1:-1:-1;10750:60:0;;10825:11;:33;;;;;;:::i;:::-;;;;;;;;;:45;;:33;;:45;;;;;;;;;;;-1:-1:-1;;;;;10825:45:0;-1:-1:-1;;;10825:45:0;-1:-1:-1;;;;;;;;;;10825:45:0;;;;;-1:-1:-1;;;;;;10825:45:0;;;;;;;;;;;;;;;;10961:20;;;:11;:20;;;;;;10940:17;;10928:30;;;;;;;;:53;;;;10996:11;;;:4;:11;;;:17;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;10996:17:0;;;;;;;;;;;;11055:20;;;:11;:20;;;;;11048:27;-1:-1:-1;10548:793:0;;;11166:148;;;;;;;;11245:7;11166:148;;;;;;11286:11;;-1:-1:-1;;;;;11166:148:0;;;;;11198:12;680:10:1;;600:98;11198:12:0;-1:-1:-1;;;;;11166:148:0;;;11130:11;;;;:4;:11;;;;;;;;11142:20;;;:11;:20;;;;;;;11130:33;;;;;;;;:::i;:::-;;;;;;;;;;:184;;:33;;:184;;;;;;;;;;;-1:-1:-1;;;;;11130:184:0;-1:-1:-1;;;11130:184:0;-1:-1:-1;;;;;;;;;;11130:184:0;;;;;-1:-1:-1;;;;;;11130:184:0;;;;;;;;;;;;;;;;;;;;;;;;;10548:793;11356:37;;;14714:25:14;;;14770:2;14755:18;;14748:34;;;14825:14;;14818:22;14798:18;;;14791:50;11356:37:0;;;;;;;14702:2:14;11356:37:0;;;10127:1274;;10011:1390;;;;:::o;1868:118:13:-;1115:4;1139:7;-1:-1:-1;;;1139:7:13;;;;1393:9;1385:38;;;;-1:-1:-1;;;1385:38:13;;;;;;;:::i;:::-;1928:7:::1;:14:::0;;-1:-1:-1;;;;1928:14:13::1;-1:-1:-1::0;;;1928:14:13::1;::::0;;1958:20:::1;1965:12;680:10:1::0;;600:98;1965:12:13::1;1958:20;::::0;-1:-1:-1;;;;;7366:32:14;;;7348:51;;7336:2;7321:18;1958:20:13::1;;;;;;;1868:118::o:0;2127:120::-;1115:4;1139:7;-1:-1:-1;;;1139:7:13;;;;1663:41;;;;-1:-1:-1;;;1663:41:13;;9592:2:14;1663:41:13;;;9574:21:14;9631:2;9611:18;;;9604:30;-1:-1:-1;;;9650:18:14;;;9643:50;9710:18;;1663:41:13;9390:344:14;1663:41:13;2196:5:::1;2186:15:::0;;-1:-1:-1;;;;2186:15:13::1;::::0;;2217:22:::1;680:10:1::0;2226:12:13::1;600:98:1::0;15368:217:0;15488:6;;:27;;-1:-1:-1;;;15488:27:0;;;;;14474:25:14;;;15433:5:0;;;;-1:-1:-1;;;;;15488:6:0;;;;:18;;14447::14;;15488:27:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;15451:64;;;;;;;;;;15545:10;326:1;15533:22;;;;:::i;:::-;15526:29;15368:217;-1:-1:-1;;;15368:217:0:o;2157:173:12:-;2213:16;2232:6;;-1:-1:-1;;;;;2249:17:12;;;-1:-1:-1;;;;;;2249:17:12;;;;;;2282:40;;2232:6;;;;;;;2282:40;;2213:16;2282:40;2202:128;2157:173;:::o;4304:400:0:-;1115:4:13;1139:7;-1:-1:-1;;;1139:7:13;;;;1393:9;1385:38;;;;-1:-1:-1;;;1385:38:13;;;;;;;:::i;:::-;14024:18:0::1;;14007:14;;:35;14003:303;;;14237:6;1508:11;14157:21;;14114:18;;14096:15;:36;;;;:::i;:::-;14095:83;;;;:::i;:::-;:121;;;;:::i;:::-;14094:149;;;;:::i;:::-;14059:14;;:184;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;14279:15:0::1;14258:18;:36:::0;14003:303:::1;4466:131:::2;::::0;;::::2;::::0;::::2;::::0;;::::2;::::0;;::::2;::::0;;-1:-1:-1;;;;;4569:15:0::2;4466:131:::0;::::2;;::::0;;::::2;::::0;;;-1:-1:-1;;;;;4466:131:0;;::::2;::::0;;;;;;-1:-1:-1;4450:13:0;;;:4:::2;:13:::0;;;;;;:147;;;;;;;;;;::::2;-1:-1:-1::0;;;4450:147:0::2;-1:-1:-1::0;;;;;4450:147:0;;;::::2;::::0;::::2;-1:-1:-1::0;;;;;;4450:147:0;;;;::::2;::::0;;;;::::2;::::0;;;::::2;::::0;;;::::2;::::0;;::::2;4608:26:::0;;4450:147;;-1:-1:-1;4608:26:0::2;::::0;4450:147;;4608:26:::2;:::i;:::-;::::0;;;-1:-1:-1;;4650:46:0::2;::::0;;-1:-1:-1;;;;;8861:32:14;;8843:51;;8925:2;8910:18;;8903:34;;;4680:15:0::2;8953:18:14::0;;;8946:34;4650:46:0;;::::2;::::0;;;;8831:2:14;4650:46:0;;::::2;4304:400:::0;;:::o;4883:590::-;4963:13;4979:24;4995:7;4979:15;:24::i;:::-;4963:40;;;;5034:5;5014:16;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;;5115:11:0;;;;:4;:11;;;;;;;;:18;;5092:20;;;:11;:20;;;;;:41;;;5192:11;;;5223:143;;;;;;;;;;;;;;5338:11;;;-1:-1:-1;;;;;5223:143:0;;;;;;;;;-1:-1:-1;;;;;5223:143:0;;;;;;;;;5192:185;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;5192:185:0;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;5192:185:0;-1:-1:-1;;;5192:185:0;;;;;;;;;;;;;;5453:11;5423:42;;8843:51:14;;;8910:18;;;8903:34;;;8953:18;;8946:34;5423:42:0;;8816:18:14;5423:42:0;;;;;;;4952:521;4883:590;;:::o;16782:396::-;16835:7;16976:10;17023:16;17038:1;17023:12;:16;:::i;:::-;16933:203;;7005:2:14;7001:15;;;;-1:-1:-1;;;;;;6997:53:14;16933:203:0;;;6985:66:14;17013:27:0;7067:12:14;;;7060:28;17067:15:0;7104:12:14;;;7097:28;7141:12;;;7134:28;;;7178:13;;16933:203:0;;;-1:-1:-1;;16933:203:0;;;;;;;;;16901:254;;16933:203;16901:254;;;;;16782:396;-1:-1:-1;;16782:396:0:o;13449:413::-;13512:16;;13508:185;;13617:6;13595:18;;:28;;;;;;;:::i;:::-;;;;-1:-1:-1;;;13449:413:0:o;13508:185::-;13805:16;;13783:18;;13774:27;;:6;:27;:::i;:::-;13773:48;;;;:::i;:::-;13758:11;;:63;;;;;;;:::i;:::-;;;;-1:-1:-1;;13853:1:0;13832:18;:22;-1:-1:-1;13449:413:0:o;14:850:14:-;67:5;120:3;113:4;105:6;101:17;97:27;87:55;;138:1;135;128:12;87:55;174:6;161:20;200:4;223:18;219:2;216:26;213:52;;;245:18;;:::i;:::-;291:2;288:1;284:10;314:28;338:2;334;330:11;314:28;:::i;:::-;376:15;;;407:12;;;;439:15;;;473;;;469:24;;466:33;-1:-1:-1;463:53:14;;;512:1;509;502:12;463:53;534:1;525:10;;555:1;565:270;581:2;576:3;573:11;565:270;;;656:3;643:17;704:6;697:5;693:18;686:5;683:29;673:57;;726:1;723;716:12;673:57;743:18;;781:12;;;;813;;;;603:1;594:11;565:270;;;-1:-1:-1;853:5:14;;14:850;-1:-1:-1;;;;;;;;14:850:14:o;869:132::-;945:13;;967:28;945:13;967:28;:::i;1006:160::-;1083:13;;1136:4;1125:16;;1115:27;;1105:55;;1156:1;1153;1146:12;1171:247;1230:6;1283:2;1271:9;1262:7;1258:23;1254:32;1251:52;;;1299:1;1296;1289:12;1251:52;1338:9;1325:23;1357:31;1382:5;1357:31;:::i;1423:251::-;1493:6;1546:2;1534:9;1525:7;1521:23;1517:32;1514:52;;;1562:1;1559;1552:12;1514:52;1594:9;1588:16;1613:31;1638:5;1613:31;:::i;1679:936::-;1776:6;1784;1792;1800;1808;1861:3;1849:9;1840:7;1836:23;1832:33;1829:53;;;1878:1;1875;1868:12;1829:53;1917:9;1904:23;1936:31;1961:5;1936:31;:::i;:::-;1986:5;-1:-1:-1;2043:2:14;2028:18;;2015:32;2056:33;2015:32;2056:33;:::i;:::-;2108:7;-1:-1:-1;2162:2:14;2147:18;;2134:32;;-1:-1:-1;2217:2:14;2202:18;;2189:32;2240:18;2270:14;;;2267:34;;;2297:1;2294;2287:12;2267:34;2335:6;2324:9;2320:22;2310:32;;2380:7;2373:4;2369:2;2365:13;2361:27;2351:55;;2402:1;2399;2392:12;2351:55;2442:2;2429:16;2468:2;2460:6;2457:14;2454:34;;;2484:1;2481;2474:12;2454:34;2529:7;2524:2;2515:6;2511:2;2507:15;2503:24;2500:37;2497:57;;;2550:1;2547;2540:12;2497:57;1679:936;;;;-1:-1:-1;1679:936:14;;-1:-1:-1;2581:2:14;2573:11;;2603:6;1679:936;-1:-1:-1;;;1679:936:14:o;2620:481::-;2712:6;2720;2773:2;2761:9;2752:7;2748:23;2744:32;2741:52;;;2789:1;2786;2779:12;2741:52;2828:9;2815:23;2847:31;2872:5;2847:31;:::i;:::-;2897:5;-1:-1:-1;2953:2:14;2938:18;;2925:32;2980:18;2969:30;;2966:50;;;3012:1;3009;3002:12;2966:50;3035:60;3087:7;3078:6;3067:9;3063:22;3035:60;:::i;:::-;3025:70;;;2620:481;;;;;:::o;3106:475::-;3195:6;3203;3256:2;3244:9;3235:7;3231:23;3227:32;3224:52;;;3272:1;3269;3262:12;3224:52;3312:9;3299:23;3345:18;3337:6;3334:30;3331:50;;;3377:1;3374;3367:12;3331:50;3400:60;3452:7;3443:6;3432:9;3428:22;3400:60;:::i;:::-;3390:70;;;3510:2;3499:9;3495:18;3482:32;3523:28;3545:5;3523:28;:::i;:::-;3570:5;3560:15;;;3106:475;;;;;:::o;3586:615::-;3672:6;3680;3733:2;3721:9;3712:7;3708:23;3704:32;3701:52;;;3749:1;3746;3739:12;3701:52;3789:9;3776:23;3818:18;3859:2;3851:6;3848:14;3845:34;;;3875:1;3872;3865:12;3845:34;3913:6;3902:9;3898:22;3888:32;;3958:7;3951:4;3947:2;3943:13;3939:27;3929:55;;3980:1;3977;3970:12;3929:55;4020:2;4007:16;4046:2;4038:6;4035:14;4032:34;;;4062:1;4059;4052:12;4032:34;4115:7;4110:2;4100:6;4097:1;4093:14;4089:2;4085:23;4081:32;4078:45;4075:65;;;4136:1;4133;4126:12;4075:65;4167:2;4159:11;;;;;4189:6;;-1:-1:-1;3586:615:14;;-1:-1:-1;;;;3586:615:14:o;4206:241::-;4262:6;4315:2;4303:9;4294:7;4290:23;4286:32;4283:52;;;4331:1;4328;4321:12;4283:52;4370:9;4357:23;4389:28;4411:5;4389:28;:::i;4452:899::-;4575:6;4583;4591;4599;4607;4615;4623;4631;4639;4692:3;4680:9;4671:7;4667:23;4663:33;4660:53;;;4709:1;4706;4699:12;4660:53;4741:9;4735:16;4760:28;4782:5;4760:28;:::i;:::-;4807:5;-1:-1:-1;4831:47:14;4874:2;4859:18;;4831:47;:::i;:::-;4821:57;;4897:47;4940:2;4929:9;4925:18;4897:47;:::i;:::-;4887:57;;4963:47;5006:2;4995:9;4991:18;4963:47;:::i;:::-;4953:57;;5029:48;5072:3;5061:9;5057:19;5029:48;:::i;:::-;5019:58;;5096:48;5139:3;5128:9;5124:19;5096:48;:::i;:::-;5086:58;;5163:48;5206:3;5195:9;5191:19;5163:48;:::i;:::-;5153:58;;5230:48;5273:3;5262:9;5258:19;5230:48;:::i;:::-;5220:58;;5297:48;5340:3;5329:9;5325:19;5297:48;:::i;:::-;5287:58;;4452:899;;;;;;;;;;;:::o;5356:973::-;5450:6;5503:3;5491:9;5482:7;5478:23;5474:33;5471:53;;;5520:1;5517;5510:12;5471:53;5546:22;;:::i;:::-;5591:37;5618:9;5591:37;:::i;:::-;5584:5;5577:52;5661:47;5704:2;5693:9;5689:18;5661:47;:::i;:::-;5656:2;5649:5;5645:14;5638:71;5741:47;5784:2;5773:9;5769:18;5741:47;:::i;:::-;5736:2;5729:5;5725:14;5718:71;5821:47;5864:2;5853:9;5849:18;5821:47;:::i;:::-;5816:2;5809:5;5805:14;5798:71;5902:48;5945:3;5934:9;5930:19;5902:48;:::i;:::-;5896:3;5889:5;5885:15;5878:73;5984:48;6027:3;6016:9;6012:19;5984:48;:::i;:::-;5978:3;5971:5;5967:15;5960:73;6066:48;6109:3;6098:9;6094:19;6066:48;:::i;:::-;6060:3;6053:5;6049:15;6042:73;6148:48;6191:3;6180:9;6176:19;6148:48;:::i;:::-;6142:3;6135:5;6131:15;6124:73;6216:3;6251:47;6294:2;6283:9;6279:18;6251:47;:::i;:::-;6235:14;;;6228:71;6239:5;5356:973;-1:-1:-1;;;5356:973:14:o;6334:180::-;6393:6;6446:2;6434:9;6425:7;6421:23;6417:32;6414:52;;;6462:1;6459;6452:12;6414:52;-1:-1:-1;6485:23:14;;6334:180;-1:-1:-1;6334:180:14:o;6519:248::-;6587:6;6595;6648:2;6636:9;6627:7;6623:23;6619:32;6616:52;;;6664:1;6661;6654:12;6616:52;-1:-1:-1;;6687:23:14;;;6757:2;6742:18;;;6729:32;;-1:-1:-1;6519:248:14:o;7802:555::-;-1:-1:-1;;;;;8125:15:14;;;8107:34;;8177:15;;;;8172:2;8157:18;;8150:43;8224:2;8209:18;;8202:34;;;;8272:3;8267:2;8252:18;;8245:31;;;8050:4;8292:19;;;8285:30;8087:3;8332:19;;7802:555::o;11246:342::-;11448:2;11430:21;;;11487:2;11467:18;;;11460:30;-1:-1:-1;;;11521:2:14;11506:18;;11499:48;11579:2;11564:18;;11246:342::o;11593:340::-;11795:2;11777:21;;;11834:2;11814:18;;;11807:30;-1:-1:-1;;;11868:2:14;11853:18;;11846:46;11924:2;11909:18;;11593:340::o;12284:356::-;12486:2;12468:21;;;12505:18;;;12498:30;12564:34;12559:2;12544:18;;12537:62;12631:2;12616:18;;12284:356::o;15375:252::-;15447:2;15441:9;15489:3;15477:16;;15523:18;15508:34;;15544:22;;;15505:62;15502:88;;;15570:18;;:::i;:::-;15606:2;15599:22;15375:252;:::o;15632:275::-;15703:2;15697:9;15768:2;15749:13;;-1:-1:-1;;15745:27:14;15733:40;;15803:18;15788:34;;15824:22;;;15785:62;15782:88;;;15850:18;;:::i;:::-;15886:2;15879:22;15632:275;;-1:-1:-1;15632:275:14:o;15912:128::-;15952:3;15983:1;15979:6;15976:1;15973:13;15970:39;;;15989:18;;:::i;:::-;-1:-1:-1;16025:9:14;;15912:128::o;16045:120::-;16085:1;16111;16101:35;;16116:18;;:::i;:::-;-1:-1:-1;16150:9:14;;16045:120::o;16170:168::-;16210:7;16276:1;16272;16268:6;16264:14;16261:1;16258:21;16253:1;16246:9;16239:17;16235:45;16232:71;;;16283:18;;:::i;:::-;-1:-1:-1;16323:9:14;;16170:168::o;16343:125::-;16383:4;16411:1;16408;16405:8;16402:34;;;16416:18;;:::i;:::-;-1:-1:-1;16453:9:14;;16343:125::o;16473:195::-;16511:4;16548;16545:1;16541:12;16580:4;16577:1;16573:12;16605:3;16600;16597:12;16594:38;;;16612:18;;:::i;:::-;16649:13;;;16473:195;-1:-1:-1;;;16473:195:14:o;16673:135::-;16712:3;-1:-1:-1;;16733:17:14;;16730:43;;;16753:18;;:::i;:::-;-1:-1:-1;16800:1:14;16789:13;;16673:135::o;16813:112::-;16845:1;16871;16861:35;;16876:18;;:::i;:::-;-1:-1:-1;16910:9:14;;16813:112::o;16930:127::-;16991:10;16986:3;16982:20;16979:1;16972:31;17022:4;17019:1;17012:15;17046:4;17043:1;17036:15;17062:127;17123:10;17118:3;17114:20;17111:1;17104:31;17154:4;17151:1;17144:15;17178:4;17175:1;17168:15;17194:127;17255:10;17250:3;17246:20;17243:1;17236:31;17286:4;17283:1;17276:15;17310:4;17307:1;17300:15;17326:127;17387:10;17382:3;17378:20;17375:1;17368:31;17418:4;17415:1;17408:15;17442:4;17439:1;17432:15;17458:127;17519:10;17514:3;17510:20;17507:1;17500:31;17550:4;17547:1;17540:15;17574:4;17571:1;17564:15;17590:131;-1:-1:-1;;;;;17665:31:14;;17655:42;;17645:70;;17711:1;17708;17701:12;17726:118;17812:5;17805:13;17798:21;17791:5;17788:32;17778:60;;17834:1;17831;17824:12

ipfs://887ef2ae04fb238311aa128d4f0726d9eaeaf991e83598b8e2e07fb23d90a5de