Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function setApprovalForAll(address op ...
•    - function getApproved(uint256 tokenId)
•    - function isApprovedForAll(address own ...
• library SafeMath
•    - function tryAdd(uint256 a, uint256 b)
•    - function trySub(uint256 a, uint256 b)
•    - function tryMul(uint256 a, uint256 b)
•    - function tryDiv(uint256 a, uint256 b)
•    - function tryMod(uint256 a, uint256 b)
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b)
•    - function sub(
•    - function div(
•    - function mod(
•    - function sqrrt(uint256 a)
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResult(
• library EnumerableSet
•    - function _add(Set storage set, bytes3 ...
•    - function _remove(Set storage set, byt ...
•    - function _contains(Set storage set, b ...
•    - function _length(Set storage set)
•    - function _at(Set storage set, uint256 ...
•    - function _values(Set storage set)
•    - function add(AddressSet storage set, ...
•    - function remove(AddressSet storage se ...
•    - function contains(AddressSet storage ...
•    - function length(AddressSet storage se ...
•    - function at(AddressSet storage set, u ...
•    - function values(AddressSet storage se ...
•    - function add(UintSet storage set, uin ...
•    - function remove(UintSet storage set, ...
•    - function contains(UintSet storage set ...
•    - function length(UintSet storage set)
•    - function at(UintSet storage set, uint ...
•    - function values(UintSet storage set)
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• interface IERC20
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
• interface INFTToken
•    - function balanceOf(address owner)
•    - function tokenOfOwnerByIndex(address ...
• interface IPriceTool
•    - function getPrice(address _token)
•  contract DigiMintMiningPool is Own ... *
•    - function onERC721Received(
•    - function deposit(address[] memory _nf ...
•    - function withdraw(address[] memory _n ...
•    - function _withdrawNftTokenIds(address ...
•    - function emergencyWithdraw()
•    - function _withdrawNftTokens(address[] ...
•    - function harvest()
•    - function _updatePool(address token)
•    - function lastTimeRewardApplicable(add ...
•    - function rewardPerToken(address _rewa ...
•    - function newReward(address _rewardTok ...
•    - function claimableRewards(
•    - function getUserNFTs(address _user,ad ...
•    - function _getReward(address _user, ad ...
•    - function _earned(
•    - function _updateReward(address accoun ...
•    - function convertFee(address _token, u ...
•    - function recieve(address _rewardToken ...
•    - function getTokenIdsForUser(address _ ...
•    - function safeTokenTransfer(address _r ...
•    - function setMaxTokenId(address _nftTo ...
•    - function addRewardToken(address _rewa ...
•    - function setRewardFee(address _reward ...
•    - function removeRewardFee(address _rew ...
•    - function rechargeDaoTreasury(address ...
•    - function recoverERC20(address tokenAd ...
•    - function setTreasury(address _treasur ...
•    - function setPriceTool(address _tool)
•    - function addNFTToken(address _token)
•    - function addCaller(address _caller)
•    - function delCaller(address _caller)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-06-20
*/

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

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

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

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

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

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

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

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

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

    /**
     * @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 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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }

    function sqrrt(uint256 a) internal pure returns (uint c) {
        if (a > 3) {
            c = a;
            uint b = add( div( a, 2), 1 );
            while (b < c) {
                c = b;
                b = div( add( div( a, b ), b), 2 );
            }
        } else if (a != 0) {
            c = 1;
        }
    }
}

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex;
                // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    function add(AddressSet storage set, address value)
    internal
    returns (bool)
    {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    function remove(AddressSet storage set, address value)
    internal
    returns (bool)
    {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    function contains(AddressSet storage set, address value)
    internal
    view
    returns (bool)
    {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    function at(AddressSet storage set, uint256 index)
    internal
    view
    returns (address)
    {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    function values(AddressSet storage set)
    internal
    view
    returns (address[] memory)
    {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

interface IERC20 {
    /**
     * @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 Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

interface INFTToken {
    function balanceOf(address owner) external view returns (uint256 balance);
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);
}

interface IPriceTool {
    function getPrice(address _token) external view returns(uint256);
}

contract DigiMintMiningPool is Ownable, ReentrancyGuard {

    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    address[] public nftTokens;
    mapping (address => bool) tokens;

    uint256 public constant ACC_NFT_PRECISION = 1e18;
    uint256 public constant SHARE_PRECISION = 1e6;
    uint256 public constant BASE_FEE_RATE = 1e5;
    // (nftAddress ,userAddress) => user deposited NFTs
    // @notice user -> nft token -> user nfts
    mapping(address => mapping(address => EnumerableSet.UintSet)) private userNfts;
    /// @notice user -> reward token -> user debt
	mapping(address => mapping(address => uint256)) public userRewardPerTokenPaid;
	/// @notice user -> user share 
	mapping(address => uint256) public userShare;
    //
    mapping(address => uint256) public maxTokenId;

    struct UserReward {
        uint256 claimedReward;
        uint256 claimableReward;
    }

    struct RewardData {
		address token;
		uint256 reward;
        uint256 totalReward;
	}

    struct Reward {
        uint256 periodFinish;
        uint256 rewardPerSecond;
        uint256 lastUpdateTime;
        uint256 rewardPerTokenStored;
        uint256 balance;
        uint256 totalProfit;
    }

    struct Fee {
        uint256 feePerSecond;
        uint256 feeRate;
        uint256 reward;
    }
    /// @notice user -> reward token -> amount; used to store reward amount
	mapping(address => mapping(address => UserReward)) public userRewards;
    // 
    address[] public rewardTokens;
    /// @notice Reward data per token
	mapping(address => Reward) public rewardData;
    //
    mapping(address => Fee) public feeData;

    uint256 public totalShare;
    address public daoTreasury;
    mapping (address => bool) public caller;
    address public priceTool;
    
    event Deposit(address indexed user,address[] _nfts,uint256[] _tokenIds);
    event Withdraw(address indexed user,address[] _nfts,uint256[] _tokenIds);
    event EmergencyWithdraw(address indexed user, uint256[] amounts);
    event RewardPaid(address indexed user, address indexed rewardToken, uint256 reward);
    event UpdatePool(address indexed token, uint256 lastUpdateTime, uint256 reward, uint256 fee);
    event AddReward(address indexed token, uint256 remainingBalance,uint256 amount,uint duration);

    constructor(address _treasury){
        daoTreasury = _treasury;
    }

    function onERC721Received(
        address operator,
        address, //from
        uint256, //tokenId
        bytes calldata //data
    ) public nonReentrant returns (bytes4) {
        require(
            operator == address(this),
            "received Nft from unauthenticated contract"
        );

        return
        bytes4(
            keccak256("onERC721Received(address,address,uint256,bytes)")
        );
    }

    function deposit(address[] memory _nfts,uint256[] memory _tokenIds) public {
        require(_nfts.length == _tokenIds.length,"Invalid value!");
        require(_nfts.length <= 50,"Invalid count!");

        uint len = _nfts.length;
        for (uint256 i = 0; i < len; i++) {
            require(tokens[_nfts[i]],"Invalid nft address!");
            require(_tokenIds[i]<=maxTokenId[_nfts[i]],"Invalid token id");
            IERC721(_nfts[i]).safeTransferFrom(msg.sender, address(this), _tokenIds[i]);
            EnumerableSet.add(userNfts[msg.sender][_nfts[i]], _tokenIds[i]);
        }

        _updateReward(msg.sender);
        uint256 share = len.mul(SHARE_PRECISION);
        userShare[msg.sender] = userShare[msg.sender].add(share);

        totalShare = totalShare.add(share);
        emit Deposit(msg.sender,_nfts,_tokenIds);
    }

    function withdraw(address[] memory _nfts,uint256[] memory _tokenIds) public {
        require(_nfts.length <= 50,"Invalid count!");
        uint256 count = _withdrawNftTokenIds(_nfts,_tokenIds);
        _updateReward(msg.sender);
        uint256 share = count.mul(SHARE_PRECISION);
        userShare[msg.sender] = userShare[msg.sender].sub(share);
        totalShare = totalShare.sub(share);
        emit Withdraw(msg.sender,_nfts,_tokenIds);
    }

    function _withdrawNftTokenIds(address[] memory _nfts,uint256[] memory _tokenIds) internal returns(uint256 _totalCounts){
        require(_nfts.length == _tokenIds.length,"Invalid value!");
        _totalCounts = _nfts.length;
        for (uint256 i = 0; i < _totalCounts; i++) {
            require(EnumerableSet.contains(userNfts[msg.sender][_nfts[i]], _tokenIds[i]),"Invalid tokenId"); 
        }

        for(uint256 i=0;i<_totalCounts;i++){
            IERC721(_nfts[i]).transferFrom(address(this), address(msg.sender), _tokenIds[i]);
            EnumerableSet.remove(userNfts[msg.sender][_nfts[i]], _tokenIds[i]);
        }        
    }

    function emergencyWithdraw() external {
        
        _updateReward(msg.sender);
        uint256 length = rewardTokens.length;
		for (uint256 i; i < length; i++) {
			address token = rewardTokens[i];
			uint256 reward = userRewards[msg.sender][token].claimableReward;
			if (reward > 0) {
				userRewards[msg.sender][token].claimableReward = 0;
                feeData[token].reward = feeData[token].reward.add(reward);
			}
		}
        uint len = nftTokens.length;
        uint256[] memory amounts = new uint256[](len); 
        for (uint256 i = 0; i < len; i++) {
            uint256 amount = EnumerableSet.length(userNfts[msg.sender][nftTokens[i]]);
            if(amount > 50){
                amount = 50;
            }
            amounts[i] = amount;
        }
        
        uint256 count = _withdrawNftTokens(nftTokens,amounts);
        uint256 share = count.mul(SHARE_PRECISION);
        userShare[msg.sender] = userShare[msg.sender].sub(share);
        totalShare = totalShare.sub(share);
        emit EmergencyWithdraw(msg.sender,amounts);
    }

    function _withdrawNftTokens(address[] memory _nfts,uint256[] memory _amounts) internal returns(uint256 _totalCounts){
        uint len = _nfts.length;
        for(uint256 i=0;i<len;i++){
            uint256 count = _amounts[i];
            uint256[] memory tokenIds = new uint256[](count);

            // check
            for(uint256 j =0;j<count;j++){
                uint256 tokenId = EnumerableSet.at(userNfts[msg.sender][_nfts[i]],j);
                tokenIds[j] = tokenId;
            }
            // remove
            for(uint256 k=0;k<count;k++){
                uint256 tokenId = tokenIds[k];
                IERC721(_nfts[i]).transferFrom(address(this), address(msg.sender), tokenId);
                EnumerableSet.remove(userNfts[msg.sender][_nfts[i]], tokenId);
            }
            _totalCounts += count;
        }
    }

    function harvest() public nonReentrant {
        _updateReward(msg.sender);
		_getReward(msg.sender, rewardTokens);
    }

    function _updatePool(address token) internal returns(uint256) {

        (uint256 rpt,uint256 reward,uint256 fee) = rewardPerToken(token);
        
	    Reward storage r = rewardData[token];
		r.rewardPerTokenStored = rpt;
        emit UpdatePool(token,r.lastUpdateTime,reward,fee);
		r.lastUpdateTime = lastTimeRewardApplicable(token);
        r.balance = r.balance.add(reward).add(fee);
        r.totalProfit = r.totalProfit.add(reward);
        feeData[token].reward = feeData[token].reward.add(fee);
        
        return rpt;
    }

	/**
	 * @notice Returns reward applicable timestamp.
	 */
	function lastTimeRewardApplicable(address _rewardToken) public view returns (uint256) {
		uint256 periodFinish = rewardData[_rewardToken].periodFinish;
		return block.timestamp < periodFinish ? block.timestamp : periodFinish;
	}

	/**
	 * @notice Reward amount per token
	 * @dev Reward is distributed only for locks.
	 * @param _rewardToken for reward
	 */
	function rewardPerToken(address _rewardToken) public view returns (uint256 rptStored,uint256 reward,uint256 fee) {
		rptStored = rewardData[_rewardToken].rewardPerTokenStored;
		if (totalShare > 0) {
			reward = newReward(_rewardToken);
            uint256 feePerSecond = feeData[_rewardToken].feePerSecond;
            if(feePerSecond > 0){
                uint256 stableFee = lastTimeRewardApplicable(_rewardToken).sub(rewardData[_rewardToken].lastUpdateTime).mul(feePerSecond);
                fee = convertFee(_rewardToken,stableFee);
                if(fee > reward){
                    fee = reward;
                }
            }
            if(feeData[_rewardToken].feeRate > 0){
                uint256 tmpReward = reward;
                tmpReward = tmpReward.sub(fee);
                fee = tmpReward.mul(feeData[_rewardToken].feeRate).div(BASE_FEE_RATE).add(fee);
                reward = reward.sub(fee);
            }

			rptStored = rptStored.add(reward.mul(ACC_NFT_PRECISION).div(totalShare));
		}
	}

    function newReward(address _rewardToken) internal view returns (uint256 reward) {
        reward = lastTimeRewardApplicable(_rewardToken).sub(rewardData[_rewardToken].lastUpdateTime).mul(
				rewardData[_rewardToken].rewardPerSecond
			).div(ACC_NFT_PRECISION);
    }

	/**
	 * @notice Address and claimable amount of all reward tokens for the given account.
	 * @param account for rewards
	 */
	function claimableRewards(
		address account
	) public view returns (RewardData[] memory rewardsData) {
        uint256 length = rewardTokens.length;
		rewardsData = new RewardData[](length);
		for (uint256 i = 0; i < length; i++) {
			rewardsData[i].token = rewardTokens[i];
            (uint256 rpt,,) = rewardPerToken(rewardsData[i].token);
            uint256 reward = _earned(
				account,
				rewardsData[i].token,
				userShare[account],
				rpt
			);
            rewardsData[i].reward = reward;
            rewardsData[i].totalReward = reward.add(userRewards[account][rewardTokens[i]].claimedReward);
		}
		return rewardsData;
	}

    function getUserNFTs(address _user,address _nft) public view returns(uint256[] memory){

        uint256 amount = EnumerableSet.length(userNfts[_user][_nft]);
        uint256[] memory tokenIds = new uint256[](amount); 
        // check
        for(uint256 j =0;j<amount;j++){
            uint256 tokenId = EnumerableSet.at(userNfts[_user][_nft],j);
            tokenIds[j] = tokenId;
        }
        return tokenIds;
    }

    /*
     * @notice User gets reward
	 */
	function _getReward(address _user, address[] memory _rewardTokens) internal  {

		uint256 length = _rewardTokens.length;
		for (uint256 i; i < length; i++) {
			address token = _rewardTokens[i];
			uint256 reward = userRewards[_user][token].claimableReward;
			if (reward > 0) {
				// rewards[_user][token] = 0;
                userRewards[_user][token] = UserReward({
                    claimedReward: userRewards[_user][token].claimedReward.add(reward),
                    claimableReward:0
                });
				rewardData[token].balance = reward < rewardData[token].balance? rewardData[token].balance.sub(reward):0;
                IERC20(token).safeTransfer(_user, reward);
				emit RewardPaid(_user, token, reward);
			}
		}
	}

	/**
	 * @notice Calculate earnings.
	 */
	function _earned(
		address _user,
		address _rewardToken,
		uint256 _share,
		uint256 _currentRewardPerToken
	) internal view returns (uint256 earnings) {
		earnings = userRewards[_user][_rewardToken].claimableReward;
		uint256 realRPT = _currentRewardPerToken.sub(userRewardPerTokenPaid[_user][_rewardToken]);
		earnings = earnings.add(_share.mul(realRPT).div(ACC_NFT_PRECISION));
	}

	/**
	 * @notice Update user reward info.
	 */
	function _updateReward(address account) internal {
		uint256 share = userShare[msg.sender];
		uint256 length = rewardTokens.length;
		for (uint256 i = 0; i < length; i++) {
			address token = rewardTokens[i];
			uint256 rpt = _updatePool(token);

			if (account != address(this)) {
				userRewards[account][token].claimableReward = _earned(account, token, share, rpt);
				userRewardPerTokenPaid[account][token] = rpt;
			}
		}
	}

    function convertFee(address _token, uint256 _stableAmount) public view returns(uint256) {
        uint256 price = IPriceTool(priceTool).getPrice(_token);
        uint256 multiple = 10 ** IERC20(_token).decimals();
        return _stableAmount.mul(multiple).div(price);
    }

    function recieve(address _rewardToken,uint256 _amount, uint256 _minutes) external returns ( bool ) {
        require(caller[msg.sender],"Invalid address!");
        require(rewardData[_rewardToken].lastUpdateTime > 0, "Not ready!");
        require(_amount > 0,"Invalid amount!");

        _updatePool(_rewardToken);
        uint256 oldBal = IERC20(_rewardToken).balanceOf(address(this));
        IERC20(_rewardToken).safeTransferFrom(msg.sender, address(this), _amount);
        uint256 allocRewardAmount = rewardData[_rewardToken].balance;
        if(allocRewardAmount > oldBal) {
            allocRewardAmount = oldBal;
        }
        uint256 remainingBal = oldBal.sub(allocRewardAmount);
        uint256 tmpBal = remainingBal;
        remainingBal = remainingBal.add(_amount);
        uint256 unit = 1 minutes;
        rewardData[_rewardToken].rewardPerSecond = remainingBal.mul(ACC_NFT_PRECISION).div(_minutes).div(unit);
        rewardData[_rewardToken].lastUpdateTime = block.timestamp;
        rewardData[_rewardToken].periodFinish = _minutes.mul(unit).add(block.timestamp);

        emit AddReward(_rewardToken,tmpBal,_amount,_minutes);
        return true;
    }

    function getTokenIdsForUser(address _nft,address _user, uint _count) internal view returns(uint256[] memory) {
        uint256 balance = INFTToken(_nft).balanceOf(_user);
        require(balance >= _count,"Invalid count!");
        uint256[] memory re = new uint256[](_count);
        for (uint256 i = 0;i<_count;i++){
            uint256 tokenId = INFTToken(_nft).tokenOfOwnerByIndex(_user, i);
            re[i] = tokenId;            
        }
        return re;
    }

    function safeTokenTransfer(address _rewardToken , address _to, uint256 _amount) internal {
        uint256 tokenBal = IERC20(_rewardToken).balanceOf(address(this));
        if (_amount > tokenBal) {
            if (tokenBal > 0) {
                _amount = tokenBal;
            }
        }
        if(_amount>0) {
            IERC20(_rewardToken).safeTransfer(_to, _amount);
        }
    }

    function setMaxTokenId(address _nftToken,uint256 _tokenId) public {
        require(caller[msg.sender], "Not caller!");
        require(tokens[_nftToken],"Ivalid token");
        maxTokenId[_nftToken] = _tokenId;
    }

    /**
	 * @notice Add a new reward token to be distributed to stakers.
	 */
	function addRewardToken(address _rewardToken) external {
		require(caller[msg.sender], "Not caller!");
		require(rewardData[_rewardToken].lastUpdateTime == 0, "Already added");
        require(_rewardToken != address(0),"Invalid token!");
		rewardTokens.push(_rewardToken);
		rewardData[_rewardToken].lastUpdateTime = block.timestamp;
		rewardData[_rewardToken].periodFinish = block.timestamp;
	}

    function setRewardFee(address _rewardToken, uint256 _feePerSecond, uint256 _feeRate) public {
        require(caller[msg.sender], "not caller");
        require(rewardData[_rewardToken].lastUpdateTime > 0, "Invalid token");
       
        _updatePool(_rewardToken);
        
        Fee memory feeInfo = feeData[_rewardToken];
        feeData[_rewardToken] = Fee({
            feePerSecond: _feePerSecond,
            feeRate: _feeRate,
            reward: feeInfo.reward
        });
    }

    function removeRewardFee(address _rewardToken) public {
        rechargeDaoTreasury(_rewardToken);
        delete feeData[_rewardToken];
    }

    function rechargeDaoTreasury(address _rewardToken) public {
        require(caller[msg.sender], "not caller");
        require(rewardData[_rewardToken].lastUpdateTime > 0, "Invalid token!");
        _updatePool(_rewardToken);
        Fee memory feeInfo = feeData[_rewardToken];
        uint256 reward = feeInfo.reward;
        if(reward > 0){
            rewardData[_rewardToken].balance = reward < rewardData[_rewardToken].balance? rewardData[_rewardToken].balance.sub(reward):0;
            feeData[_rewardToken].reward = 0;
            safeTokenTransfer(_rewardToken,daoTreasury,reward);
        }
    }

    /**
	 * @notice Added to support recovering LP Rewards from other systems such as BAL to be distributed to holders.
	 */
	function recoverERC20(address tokenAddress) external onlyOwner {
		require(rewardData[tokenAddress].lastUpdateTime == 0, "active reward");
        uint256 tokenAmount = IERC20(tokenAddress).balanceOf(address(this));
		IERC20(tokenAddress).safeTransfer(owner(), tokenAmount);
	}

    function setTreasury(address _treasury) public onlyOwner {
        require(_treasury != address(0),"Invalid address!");
        daoTreasury = _treasury;
    }

    function setPriceTool(address _tool) public onlyOwner {
        require(_tool != address(0),"Invalid address");
        priceTool = _tool;
    }

    function addNFTToken(address _token) public onlyOwner {
        require(_token != address(0),"Invalid address!");
        require(nftTokens.length < 20,"Maximum count exceeded!");
        require(tokens[_token] == false,"Ivalid token");
        nftTokens.push(_token);
        tokens[_token] = true;
    }

    function addCaller(address _caller) public onlyOwner {
        require(_caller != address(0),"Invalid address!");
        caller[_caller] = true;
    }

    function delCaller(address _caller) public onlyOwner {
        require(_caller != address(0),"Invalid address!");
        caller[_caller] = false;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"remainingBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"duration","type":"uint256"}],"name":"AddReward","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address[]","name":"_nfts","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"rewardToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"lastUpdateTime","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"UpdatePool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"address[]","name":"_nfts","type":"address[]"},{"indexed":false,"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"ACC_NFT_PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"BASE_FEE_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SHARE_PRECISION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"}],"name":"addCaller","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"addNFTToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"}],"name":"addRewardToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"caller","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"claimableRewards","outputs":[{"components":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"totalReward","type":"uint256"}],"internalType":"struct DigiMintMiningPool.RewardData[]","name":"rewardsData","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_stableAmount","type":"uint256"}],"name":"convertFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"daoTreasury","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_caller","type":"address"}],"name":"delCaller","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_nfts","type":"address[]"},{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"feeData","outputs":[{"internalType":"uint256","name":"feePerSecond","type":"uint256"},{"internalType":"uint256","name":"feeRate","type":"uint256"},{"internalType":"uint256","name":"reward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"},{"internalType":"address","name":"_nft","type":"address"}],"name":"getUserNFTs","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"}],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"nftTokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"bytes","name":"","type":"bytes"}],"name":"onERC721Received","outputs":[{"internalType":"bytes4","name":"","type":"bytes4"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"priceTool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"}],"name":"rechargeDaoTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"uint256","name":"_minutes","type":"uint256"}],"name":"recieve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"}],"name":"removeRewardFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewardData","outputs":[{"internalType":"uint256","name":"periodFinish","type":"uint256"},{"internalType":"uint256","name":"rewardPerSecond","type":"uint256"},{"internalType":"uint256","name":"lastUpdateTime","type":"uint256"},{"internalType":"uint256","name":"rewardPerTokenStored","type":"uint256"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"totalProfit","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"}],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"rptStored","type":"uint256"},{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"fee","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewardTokens","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_nftToken","type":"address"},{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"setMaxTokenId","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_tool","type":"address"}],"name":"setPriceTool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_rewardToken","type":"address"},{"internalType":"uint256","name":"_feePerSecond","type":"uint256"},{"internalType":"uint256","name":"_feeRate","type":"uint256"}],"name":"setRewardFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_treasury","type":"address"}],"name":"setTreasury","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalShare","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":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"userRewards","outputs":[{"internalType":"uint256","name":"claimedReward","type":"uint256"},{"internalType":"uint256","name":"claimableReward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"_nfts","type":"address[]"},{"internalType":"uint256[]","name":"_tokenIds","type":"uint256[]"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000004e41c9b477cf991b4262c5c23d4793bb21aec5cf

-----Decoded View---------------
Arg [0] : _treasury (address): 0x4E41C9B477cF991B4262c5c23d4793bB21AEC5Cf

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000004e41c9b477cf991b4262c5c23d4793bb21aec5cf

42651:18044:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44345:25;;;;;;;;;18108::1;;;18096:2;18081:18;44345:25:0;;;;;;;;42858:48;;42902:4;42858:48;;45092:439;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;;8977:33:1;;;8959:52;;8947:2;8932:18;45092:439:0;8914:103:1;52733:434:0;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;43426:45::-;;;;;;:::i;:::-;;;;;;;;;;;;;;57619:403;;;;;;:::i;:::-;;:::i;:::-;;44410:39;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;8788:14:1;;8781:22;8763:41;;8751:2;8736:18;44410:39:0;8718:92:1;60537:155:0;;;;;;:::i;:::-;;:::i;55209:1197::-;;;;;;:::i;:::-;;:::i;49498:124::-;;;:::i;44239:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;19008:25:1;;;19064:2;19049:18;;19042:34;;;;19092:18;;;19085:34;;;;19150:2;19135:18;;19128:34;19193:3;19178:19;;19171:35;19237:3;19222:19;;19215:35;18995:3;18980:19;44239:44:0;18962:294:1;44298:38:0;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18599:25:1;;;18655:2;18640:18;;18633:34;;;;18683:18;;;18676:34;18587:2;18572:18;44298:38:0;18554:162:1;58540:145:0;;;;;;:::i;:::-;;:::i;42913:45::-;;42955:3;42913:45;;50248:231;;;;;;:::i;:::-;;:::i;42965:43::-;;43005:3;42965:43;;43252:77;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;2538:103;;;:::i;60375:154::-;;;;;;:::i;:::-;;:::i;43367:44::-;;;;;;:::i;:::-;;;;;;;;;;;;;;44377:26;;;;;-1:-1:-1;;;;;44377:26:0;;;;;;-1:-1:-1;;;;;5931:32:1;;;5913:51;;5901:2;5886:18;44377:26:0;5868:102:1;44167:29:0;;;;;;:::i;:::-;;:::i;60056:311::-;;;;;;:::i;:::-;;:::i;54923:278::-;;;;;;:::i;:::-;;:::i;57311:222::-;;;;;;:::i;:::-;;:::i;1890:87::-;1936:7;1963:6;-1:-1:-1;;;;;1963:6:0;1890:87;;58030:502;;;;;;:::i;:::-;;:::i;59443:281::-;;;;;;:::i;:::-;;:::i;44456:24::-;;;;;-1:-1:-1;;;;;44456:24:0;;;58693:617;;;;;;:::i;:::-;;:::i;44082:69::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;18318:25:1;;;18374:2;18359:18;;18352:34;;;;18291:18;44082:69:0;18273:119:1;47533:1089:0;;;:::i;52070:655::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;46408:456::-;;;;;;:::i;:::-;;:::i;42784:26::-;;;;;;:::i;:::-;;:::i;45539:861::-;;;;;;:::i;:::-;;:::i;59732:161::-;;;;;;:::i;:::-;;:::i;50617:1039::-;;;;;;:::i;:::-;;:::i;2796:201::-;;;;;;:::i;:::-;;:::i;59901:147::-;;;;;;:::i;:::-;;:::i;45092:439::-;45266:6;33097:1;33695:7;;:19;;33687:63;;;;-1:-1:-1;;;33687:63:0;;17804:2:1;33687:63:0;;;17786:21:1;17843:2;17823:18;;;17816:30;17882:33;17862:18;;;17855:61;17933:18;;33687:63:0;;;;;;;;;33097:1;33828:7;:18;-1:-1:-1;;;;;45307:25:0;::::1;45327:4;45307:25;45285:117;;;::::0;-1:-1:-1;;;45285:117:0;;16272:2:1;45285:117:0::1;::::0;::::1;16254:21:1::0;16311:2;16291:18;;;16284:30;16350:34;16330:18;;;16323:62;-1:-1:-1;;;16401:18:1;;;16394:40;16451:19;;45285:117:0::1;16244:232:1::0;45285:117:0::1;-1:-1:-1::0;45452:60:0::1;33053:1:::0;34007:22;;45092:439;;-1:-1:-1;;;;;45092:439:0:o;52733:434::-;-1:-1:-1;;;;;52870:15:0;;;52832:14;52870:15;;;:8;:15;;;;;;;;:21;;;;;;;;;;;52802:16;;52832:14;52849:43;;:20;:43::i;:::-;52832:60;;52903:25;52945:6;52931:21;;;;;;-1:-1:-1;;;52931:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52931:21:0;;52903:49;;52986:9;52982:152;53001:6;52999:1;:8;52982:152;;;-1:-1:-1;;;;;53062:15:0;;;53027;53062;;;:8;:15;;;;;;;;:21;;;;;;;;;;;53045:41;;53084:1;53045:16;:41::i;:::-;53027:59;;53115:7;53101:8;53110:1;53101:11;;;;;;-1:-1:-1;;;53101:11:0;;;;;;;;;;;;;;;;;;:21;-1:-1:-1;53008:3:0;;;;:::i;:::-;;;;52982:152;;;-1:-1:-1;53151:8:0;-1:-1:-1;;52733:434:0;;;;;:::o;57619:403::-;57694:10;57687:18;;;;:6;:18;;;;;;;;57679:42;;;;-1:-1:-1;;;57679:42:0;;9954:2:1;57679:42:0;;;9936:21:1;9993:2;9973:18;;;9966:30;-1:-1:-1;;;10012:18:1;;;10005:41;10063:18;;57679:42:0;9926:161:1;57679:42:0;-1:-1:-1;;;;;57734:24:0;;;;;;:10;:24;;;;;:39;;;:44;57726:70;;;;-1:-1:-1;;;57726:70:0;;15930:2:1;57726:70:0;;;15912:21:1;15969:2;15949:18;;;15942:30;-1:-1:-1;;;15988:18:1;;;15981:43;16041:18;;57726:70:0;15902:163:1;57726:70:0;-1:-1:-1;;;;;57815:26:0;;57807:52;;;;-1:-1:-1;;;57807:52:0;;13175:2:1;57807:52:0;;;13157:21:1;13214:2;13194:18;;;13187:30;-1:-1:-1;;;13233:18:1;;;13226:44;13287:18;;57807:52:0;13147:164:1;57807:52:0;57864:12;:31;;;;;;;;;;;;-1:-1:-1;;;;;57864:31:0;;;-1:-1:-1;;;;;;57864:31:0;;;;;;;-1:-1:-1;57900:24:0;;;:10;57864:31;57900:24;;;;57942:15;57900:39;;;:57;;;57962:55;;57619:403::o;60537:155::-;1776:13;:11;:13::i;:::-;-1:-1:-1;;;;;60609:21:0;::::1;60601:49;;;;-1:-1:-1::0;;;60601:49:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;60661:15:0::1;60679:5;60661:15:::0;;;:6:::1;:15;::::0;;;;:23;;-1:-1:-1;;60661:23:0::1;::::0;;60537:155::o;55209:1197::-;55334:10;55301:4;55327:18;;;:6;:18;;;;;;;;55319:46;;;;-1:-1:-1;;;55319:46:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;55384:24:0;;55426:1;55384:24;;;:10;:24;;;;;:39;;;55376:66;;;;-1:-1:-1;;;55376:66:0;;13518:2:1;55376:66:0;;;13500:21:1;13557:2;13537:18;;;13530:30;-1:-1:-1;;;13576:18:1;;;13569:40;13626:18;;55376:66:0;13490:160:1;55376:66:0;55471:1;55461:7;:11;55453:38;;;;-1:-1:-1;;;55453:38:0;;14200:2:1;55453:38:0;;;14182:21:1;14239:2;14219:18;;;14212:30;-1:-1:-1;;;14258:18:1;;;14251:45;14313:18;;55453:38:0;14172:165:1;55453:38:0;55504:25;55516:12;55504:11;:25::i;:::-;-1:-1:-1;55557:45:0;;-1:-1:-1;;;55557:45:0;;55596:4;55557:45;;;5913:51:1;55540:14:0;;-1:-1:-1;;;;;55557:30:0;;;;;5886:18:1;;55557:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55540:62;-1:-1:-1;55613:73:0;-1:-1:-1;;;;;55613:37:0;;55651:10;55671:4;55678:7;55613:37;:73::i;:::-;-1:-1:-1;;;;;55725:24:0;;55697:25;55725:24;;;:10;:24;;;;;:32;;;55771:26;;;55768:84;;;-1:-1:-1;55834:6:0;55768:84;55862:20;55885:29;:6;55896:17;55885:10;:29::i;:::-;55862:52;-1:-1:-1;55862:52:0;55980:25;55862:52;55997:7;55980:16;:25::i;:::-;55965:40;-1:-1:-1;56031:9:0;56094:59;56031:9;56094:49;56134:8;56094:49;55965:40;42902:4;56094:16;:35::i;:::-;:39;;:49::i;:59::-;-1:-1:-1;;;;;56051:24:0;;;;;;:10;:24;;;;;:40;;;:102;;;;56206:15;56164:39;;;;:57;;;56272:39;;:18;:8;56285:4;56272:12;:18::i;:::-;:22;;:39::i;:::-;-1:-1:-1;;;;;56232:24:0;;;;;;:10;:24;;;;;;;;;:79;;;;56329:47;;18599:25:1;;;18640:18;;;18633:34;;;18683:18;;18676:34;;;56232:24:0;56329:47;;18587:2:1;18572:18;56329:47:0;;;;;;;56394:4;56387:11;;;;;;;55209:1197;;;;;;:::o;49498:124::-;33097:1;33695:7;;:19;;33687:63;;;;-1:-1:-1;;;33687:63:0;;17804:2:1;33687:63:0;;;17786:21:1;17843:2;17823:18;;;17816:30;17882:33;17862:18;;;17855:61;17933:18;;33687:63:0;17776:181:1;33687:63:0;33097:1;33828:7;:18;49548:25:::1;49562:10;49548:13;:25::i;:::-;49578:36;49589:10;49601:12;49578:36;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;49578:36:0::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;;;;;;:10;:36::i;:::-;33053:1:::0;34007:22;;49498:124::o;58540:145::-;58605:33;58625:12;58605:19;:33::i;:::-;-1:-1:-1;;;;;58656:21:0;;;;;:7;:21;;;;;58649:28;;;;;;;;;;;;58540:145::o;50248:231::-;-1:-1:-1;;;;;50362:24:0;;50325:7;50362:24;;;:10;:24;;;;;:37;50411:15;:30;-1:-1:-1;50411:63:0;;50462:12;50411:63;;;50444:15;50404:70;50248:231;-1:-1:-1;;;50248:231:0:o;2538:103::-;1776:13;:11;:13::i;:::-;2603:30:::1;2630:1;2603:18;:30::i;:::-;2538:103::o:0;60375:154::-;1776:13;:11;:13::i;:::-;-1:-1:-1;;;;;60447:21:0;::::1;60439:49;;;;-1:-1:-1::0;;;60439:49:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;60499:15:0::1;;::::0;;;:6:::1;:15;::::0;;;;:22;;-1:-1:-1;;60499:22:0::1;60517:4;60499:22;::::0;;60375:154::o;44167:29::-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;44167:29:0;;-1:-1:-1;44167:29:0;:::o;60056:311::-;1776:13;:11;:13::i;:::-;-1:-1:-1;;;;;60129:20:0;::::1;60121:48;;;;-1:-1:-1::0;;;60121:48:0::1;;;;;;;:::i;:::-;60188:9;:16:::0;60207:2:::1;-1:-1:-1::0;60180:56:0::1;;;::::0;-1:-1:-1;;;60180:56:0;;17041:2:1;60180:56:0::1;::::0;::::1;17023:21:1::0;17080:2;17060:18;;;17053:30;17119:25;17099:18;;;17092:53;17162:18;;60180:56:0::1;17013:173:1::0;60180:56:0::1;-1:-1:-1::0;;;;;60255:14:0;::::1;;::::0;;;:6:::1;:14;::::0;;;;;::::1;;:23;60247:47;;;::::0;-1:-1:-1;;;60247:47:0;;15589:2:1;60247:47:0::1;::::0;::::1;15571:21:1::0;15628:2;15608:18;;;15601:30;-1:-1:-1;;;15647:18:1;;;15640:42;15699:18;;60247:47:0::1;15561:162:1::0;60247:47:0::1;60305:9;:22:::0;;::::1;::::0;;::::1;::::0;;;;::::1;::::0;;-1:-1:-1;;;;;60305:22:0;;::::1;-1:-1:-1::0;;;;;;60305:22:0;;::::1;::::0;::::1;::::0;;-1:-1:-1;60338:14:0;;;:6:::1;60305:22;60338:14:::0;;;;;:21;;-1:-1:-1;;60338:21:0::1;::::0;;::::1;::::0;;60056:311::o;54923:278::-;55049:9;;55038:38;;-1:-1:-1;;;55038:38:0;;-1:-1:-1;;;;;5931:32:1;;;55038:38:0;;;5913:51:1;55002:7:0;;;;55049:9;;;55038:30;;5886:18:1;;55038:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55022:54;;55087:16;55119:6;-1:-1:-1;;;;;55112:23:0;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55106:31;;:2;:31;:::i;:::-;55087:50;-1:-1:-1;55155:38:0;55187:5;55155:27;:13;55087:50;55155:17;:27::i;:38::-;55148:45;54923:278;-1:-1:-1;;;;;54923:278:0:o;57311:222::-;57403:10;57396:18;;;;:6;:18;;;;;;;;57388:42;;;;-1:-1:-1;;;57388:42:0;;9954:2:1;57388:42:0;;;9936:21:1;9993:2;9973:18;;;9966:30;-1:-1:-1;;;10012:18:1;;;10005:41;10063:18;;57388:42:0;9926:161:1;57388:42:0;-1:-1:-1;;;;;57449:17:0;;;;;;:6;:17;;;;;;;;57441:41;;;;-1:-1:-1;;;57441:41:0;;15589:2:1;57441:41:0;;;15571:21:1;15628:2;15608:18;;;15601:30;-1:-1:-1;;;15647:18:1;;;15640:42;15699:18;;57441:41:0;15561:162:1;57441:41:0;-1:-1:-1;;;;;57493:21:0;;;;;;;:10;:21;;;;;:32;57311:222::o;58030:502::-;58148:10;58141:18;;;;:6;:18;;;;;;;;58133:41;;;;-1:-1:-1;;;58133:41:0;;14544:2:1;58133:41:0;;;14526:21:1;14583:2;14563:18;;;14556:30;-1:-1:-1;;;14602:18:1;;;14595:40;14652:18;;58133:41:0;14516:160:1;58133:41:0;-1:-1:-1;;;;;58193:24:0;;58235:1;58193:24;;;:10;:24;;;;;:39;;;58185:69;;;;-1:-1:-1;;;58185:69:0;;12484:2:1;58185:69:0;;;12466:21:1;12523:2;12503:18;;;12496:30;-1:-1:-1;;;12542:18:1;;;12535:43;12595:18;;58185:69:0;12456:163:1;58185:69:0;58274:25;58286:12;58274:11;:25::i;:::-;-1:-1:-1;;;;;;58341:21:0;;;58320:18;58341:21;;;:7;:21;;;;;;;;58320:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;58397:127;;;;;;;;;;;;;;;;58498:14;;58397:127;;;;;;58373:21;;;;;;;;:151;;;;;;;;;;;;;58030:502::o;59443:281::-;1776:13;:11;:13::i;:::-;-1:-1:-1;;;;;59519:24:0;::::1;;::::0;;;:10:::1;:24;::::0;;;;:39:::1;;::::0;:44;59511:70:::1;;;::::0;-1:-1:-1;;;59511:70:0;;9612:2:1;59511:70:0::1;::::0;::::1;9594:21:1::0;9651:2;9631:18;;;9624:30;-1:-1:-1;;;9670:18:1;;;9663:43;9723:18;;59511:70:0::1;9584:163:1::0;59511:70:0::1;59614:45;::::0;-1:-1:-1;;;59614:45:0;;59653:4:::1;59614:45;::::0;::::1;5913:51:1::0;59592:19:0::1;::::0;-1:-1:-1;;;;;59614:30:0;::::1;::::0;::::1;::::0;5886:18:1;;59614:45:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59592:67;;59664:55;59698:7;1936::::0;1963:6;-1:-1:-1;;;;;1963:6:0;;1890:87;59698:7:::1;-1:-1:-1::0;;;;;59664:33:0;::::1;::::0;59707:11;59664:33:::1;:55::i;:::-;1800:1;59443:281:::0;:::o;58693:617::-;58777:10;58770:18;;;;:6;:18;;;;;;;;58762:41;;;;-1:-1:-1;;;58762:41:0;;14544:2:1;58762:41:0;;;14526:21:1;14583:2;14563:18;;;14556:30;-1:-1:-1;;;14602:18:1;;;14595:40;14652:18;;58762:41:0;14516:160:1;58762:41:0;-1:-1:-1;;;;;58822:24:0;;58864:1;58822:24;;;:10;:24;;;;;:39;;;58814:70;;;;-1:-1:-1;;;58814:70:0;;13175:2:1;58814:70:0;;;13157:21:1;13214:2;13194:18;;;13187:30;-1:-1:-1;;;13233:18:1;;;13226:44;13287:18;;58814:70:0;13147:164:1;58814:70:0;58895:25;58907:12;58895:11;:25::i;:::-;-1:-1:-1;;;;;;58952:21:0;;58931:18;58952:21;;;:7;:21;;;;;;;;;58931:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59029:10;;59026:277;;-1:-1:-1;;;;;59099:24:0;;;;;;:10;:24;;;;;:32;;;59090:41;;:89;;59178:1;59090:89;;;-1:-1:-1;;;;;59133:24:0;;;;;;:10;:24;;;;;:32;;;:44;;59170:6;59133:36;:44::i;:::-;-1:-1:-1;;;;;59055:24:0;;;;;;;:10;:24;;;;;;;;:32;;:124;;;;59194:7;:21;;;;;:28;;:32;;;;59272:11;;59241:50;;59066:12;;59272:11;59284:6;59241:17;:50::i;:::-;58693:617;;;:::o;47533:1089::-;47592:25;47606:10;47592:13;:25::i;:::-;47645:12;:19;47628:14;47669:306;47689:6;47685:1;:10;47669:306;;;47708:13;47724:12;47737:1;47724:15;;;;;;-1:-1:-1;;;47724:15:0;;;;;;;;;;;;;;;;;;;;;47774:10;47762:23;;:11;:23;;;;;;-1:-1:-1;;;;;47724:15:0;;;47762:30;;;;;;;;;47724:15;47762:46;;47724:15;;-1:-1:-1;47818:10:0;;47814:156;;47849:10;47886:1;47837:23;;;:11;:23;;;;;;;;-1:-1:-1;;;;;47837:30:0;;;;;;;;;:46;;:50;;;47930:7;:14;;;;;:21;;;:33;;47956:6;47930:25;:33::i;:::-;-1:-1:-1;;;;;47906:14:0;;;;;;:7;:14;;;;;:21;;:57;47814:156;47669:306;;47697:3;;;;;:::i;:::-;;;;47669:306;;;-1:-1:-1;47996:9:0;:16;47985:8;47996:16;48050:18;;;;;;-1:-1:-1;;;48050:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48050:18:0;;48023:45;;48085:9;48080:243;48104:3;48100:1;:7;48080:243;;;48176:10;48129:14;48167:20;;;:8;:20;;;;;48188:9;:12;;48146:56;;48167:20;48129:14;;48198:1;;48188:12;;;;-1:-1:-1;;;48188:12:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48188:12:0;48167:34;;;;;;;;;;;;48146:20;:56::i;:::-;48129:73;;48229:2;48220:6;:11;48217:61;;;-1:-1:-1;48260:2:0;48217:61;48305:6;48292:7;48300:1;48292:10;;;;;;-1:-1:-1;;;48292:10:0;;;;;;;;;;;;;;;;;;:19;-1:-1:-1;48109:3:0;;;;:::i;:::-;;;;48080:243;;;;48343:13;48359:37;48378:9;48359:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48359:37:0;;;;;;;;;;;;;;;;;;;;;48388:7;48359:18;:37::i;:::-;48343:53;-1:-1:-1;48407:13:0;48423:26;48343:53;42955:3;48423:9;:26::i;:::-;48494:10;48484:21;;;;:9;:21;;;;;;48407:42;;-1:-1:-1;48484:32:0;;48407:42;48484:25;:32::i;:::-;48470:10;48460:21;;;;:9;:21;;;;;:56;48540:10;;:21;;48555:5;48540:14;:21::i;:::-;48527:10;:34;48577:37;;48595:10;;48577:37;;;;48606:7;;48577:37;:::i;:::-;;;;;;;;47533:1089;;;;;:::o;52070:655::-;52202:12;:19;52141:31;;52202:19;52240:24;;;;;;-1:-1:-1;;;52240:24:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52240:24:0;;;;;;;;;;;;;;;;;52226:38;;52274:9;52269:429;52293:6;52289:1;:10;52269:429;;;52335:12;52348:1;52335:15;;;;;;-1:-1:-1;;;52335:15:0;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52335:15:0;52312:11;52324:1;52312:14;;;;;;-1:-1:-1;;;52312:14:0;;;;;;;;;;;;;;;:20;;:38;-1:-1:-1;;;;;52312:38:0;;;-1:-1:-1;;;;;52312:38:0;;;;;52366:11;52383:36;52398:11;52410:1;52398:14;;;;;;-1:-1:-1;;;52398:14:0;;;;;;;;;;;;;;;:20;;;52383:14;:36::i;:::-;52365:54;;;;52434:14;52451:89;52465:7;52479:11;52491:1;52479:14;;;;;;-1:-1:-1;;;52479:14:0;;;;;;;;;;;;;;;:20;;;52506:9;:18;52516:7;-1:-1:-1;;;;;52506:18:0;-1:-1:-1;;;;;52506:18:0;;;;;;;;;;;;;52531:3;52451:7;:89::i;:::-;52434:106;;52579:6;52555:11;52567:1;52555:14;;;;;;-1:-1:-1;;;52555:14:0;;;;;;;;;;;;;;;:21;;:30;;;;;52629:63;52640:11;:20;52652:7;-1:-1:-1;;;;;52640:20:0;-1:-1:-1;;;;;52640:20:0;;;;;;;;;;;;:37;52661:12;52674:1;52661:15;;;;;;-1:-1:-1;;;52661:15:0;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52661:15:0;52640:37;;;;;;;;;;;;:51;52629:6;;:10;:63::i;:::-;52600:11;52612:1;52600:14;;;;;;-1:-1:-1;;;52600:14:0;;;;;;;;;;;;;;;:26;;:92;;;;;52269:429;;52301:3;;;;;:::i;:::-;;;;52269:429;;;;52702:18;52070:655;;;:::o;46408:456::-;46519:2;46503:5;:12;:18;;46495:44;;;;-1:-1:-1;;;46495:44:0;;11045:2:1;46495:44:0;;;11027:21:1;11084:2;11064:18;;;11057:30;-1:-1:-1;;;11103:18:1;;;11096:44;11157:18;;46495:44:0;11017:164:1;46495:44:0;46550:13;46566:37;46587:5;46593:9;46566:20;:37::i;:::-;46550:53;;46614:25;46628:10;46614:13;:25::i;:::-;46650:13;46666:26;:5;42955:3;46666:9;:26::i;:::-;46737:10;46727:21;;;;:9;:21;;;;;;46650:42;;-1:-1:-1;46727:32:0;;46650:42;46727:25;:32::i;:::-;46713:10;46703:21;;;;:9;:21;;;;;:56;46783:10;;:21;;46798:5;46783:14;:21::i;:::-;46770:10;:34;46820:36;;46829:10;;46820:36;;;;46840:5;;46846:9;;46820:36;:::i;:::-;;;;;;;;46408:456;;;;:::o;42784:26::-;;;;;;;;;;;;45539:861;45649:9;:16;45633:5;:12;:32;45625:58;;;;-1:-1:-1;;;45625:58:0;;13857:2:1;45625:58:0;;;13839:21:1;13896:2;13876:18;;;13869:30;-1:-1:-1;;;13915:18:1;;;13908:44;13969:18;;45625:58:0;13829:164:1;45625:58:0;45718:2;45702:5;:12;:18;;45694:44;;;;-1:-1:-1;;;45694:44:0;;11045:2:1;45694:44:0;;;11027:21:1;11084:2;11064:18;;;11057:30;-1:-1:-1;;;11103:18:1;;;11096:44;11157:18;;45694:44:0;11017:164:1;45694:44:0;45762:12;;45751:8;45785:354;45809:3;45805:1;:7;45785:354;;;45842:6;:16;45849:5;45855:1;45849:8;;;;;;-1:-1:-1;;;45849:8:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;45842:16:0;;;;;;;;;;;-1:-1:-1;45842:16:0;;;;45834:48;;;;-1:-1:-1;;;45834:48:0;;12826:2:1;45834:48:0;;;12808:21:1;12865:2;12845:18;;;12838:30;-1:-1:-1;;;12884:18:1;;;12877:50;12944:18;;45834:48:0;12798:170:1;45834:48:0;45919:10;:20;45930:5;45936:1;45930:8;;;;;;-1:-1:-1;;;45930:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;45919:20:0;-1:-1:-1;;;;;45919:20:0;;;;;;;;;;;;;45905:9;45915:1;45905:12;;;;;;-1:-1:-1;;;45905:12:0;;;;;;;;;;;;;;;:34;;45897:62;;;;-1:-1:-1;;;45897:62:0;;11732:2:1;45897:62:0;;;11714:21:1;11771:2;11751:18;;;11744:30;-1:-1:-1;;;11790:18:1;;;11783:46;11846:18;;45897:62:0;11704:166:1;45897:62:0;45982:5;45988:1;45982:8;;;;;;-1:-1:-1;;;45982:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;45974:34:0;;46009:10;46029:4;46036:9;46046:1;46036:12;;;;;;-1:-1:-1;;;46036:12:0;;;;;;;;;;;;;;;45974:75;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;46091:10:0;46082:20;;;;:8;:20;;;;;46103:8;;46064:63;;-1:-1:-1;46082:20:0;;-1:-1:-1;46103:5:0;;46109:1;;46103:8;;;;-1:-1:-1;;;46103:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;46082:30:0;-1:-1:-1;;;;;46082:30:0;;;;;;;;;;;;46114:9;46124:1;46114:12;;;;;;-1:-1:-1;;;46114:12:0;;;;;;;;;;;;;;;46064:17;:63::i;:::-;-1:-1:-1;45814:3:0;;;;:::i;:::-;;;;45785:354;;;;46151:25;46165:10;46151:13;:25::i;:::-;46187:13;46203:24;:3;42955;46203:7;:24::i;:::-;46272:10;46262:21;;;;:9;:21;;;;;;46187:40;;-1:-1:-1;46262:32:0;;46187:40;46262:25;:32::i;:::-;46248:10;46238:21;;;;:9;:21;;;;;:56;46320:10;;:21;;46335:5;46320:14;:21::i;:::-;46307:10;:34;46357:35;;46365:10;;46357:35;;;;46376:5;;46382:9;;46357:35;:::i;59732:161::-;1776:13;:11;:13::i;:::-;-1:-1:-1;;;;;59808:23:0;::::1;59800:51;;;;-1:-1:-1::0;;;59800:51:0::1;;;;;;;:::i;:::-;59862:11;:23:::0;;-1:-1:-1;;;;;;59862:23:0::1;-1:-1:-1::0;;;;;59862:23:0;;;::::1;::::0;;;::::1;::::0;;59732:161::o;50617:1039::-;-1:-1:-1;;;;;50747:24:0;;50684:17;50747:24;;;:10;:24;;;;;:45;;;50801:10;;50747:45;;50684:17;;;50801:14;50797:855;;50832:23;50842:12;50832:9;:23::i;:::-;-1:-1:-1;;;;;50893:21:0;;50870:20;50893:21;;;:7;:21;;;;;:34;50823:32;;-1:-1:-1;50945:16:0;;50942:324;;-1:-1:-1;;;;;51044:24:0;;50981:17;51044:24;;;:10;:24;;;;;:39;;;51001:101;;51089:12;;51001:83;;:38;51055:12;51001:24;:38::i;:::-;:42;;:83::i;:::-;:87;;:101::i;:::-;50981:121;;51127:34;51138:12;51151:9;51127:10;:34::i;:::-;51121:40;;51189:6;51183:3;:12;51180:71;;;51225:6;51219:12;;51180:71;50942:324;;-1:-1:-1;;;;;51283:21:0;;51315:1;51283:21;;;:7;:21;;;;;:29;;;:33;51280:287;;51356:6;51393:18;51356:6;51407:3;51393:13;:18::i;:::-;-1:-1:-1;;;;;51450:21:0;;;;;;:7;:21;;;;;:29;;;51381:30;;-1:-1:-1;51436:72:0;;51504:3;;51436:63;;43005:3;;51436:44;;51381:30;;51436:13;:44::i;:72::-;51430:78;-1:-1:-1;51536:15:0;:6;51430:78;51536:10;:15::i;:::-;51527:24;;51280:287;;51634:10;;51586:60;;51600:45;;:29;:6;42902:4;51600:10;:29::i;:45::-;51586:9;;:13;:60::i;:::-;51574:72;;50797:855;;50617:1039;;;;;:::o;2796:201::-;1776:13;:11;:13::i;:::-;-1:-1:-1;;;;;2885:22:0;::::1;2877:73;;;::::0;-1:-1:-1;;;2877:73:0;;10638:2:1;2877:73:0::1;::::0;::::1;10620:21:1::0;10677:2;10657:18;;;10650:30;10716:34;10696:18;;;10689:62;-1:-1:-1;;;10767:18:1;;;10760:36;10813:19;;2877:73:0::1;10610:228:1::0;2877:73:0::1;2961:28;2980:8;2961:18;:28::i;:::-;2796:201:::0;:::o;59901:147::-;1776:13;:11;:13::i;:::-;-1:-1:-1;;;;;59974:19:0;::::1;59966:46;;;::::0;-1:-1:-1;;;59966:46:0;;10294:2:1;59966:46:0::1;::::0;::::1;10276:21:1::0;10333:2;10313:18;;;10306:30;-1:-1:-1;;;10352:18:1;;;10345:45;10407:18;;59966:46:0::1;10266:165:1::0;59966:46:0::1;60023:9;:17:::0;;-1:-1:-1;;;;;;60023:17:0::1;-1:-1:-1::0;;;;;60023:17:0;;;::::1;::::0;;;::::1;::::0;;59901:147::o;30788:114::-;30848:7;30875:19;30883:3;27385:18;;27302:109;31256:137;31327:7;31362:22;31366:3;31378:5;31362:3;:22::i;2055:132::-;1936:7;1963:6;-1:-1:-1;;;;;1963:6:0;679:10;2119:23;2111:68;;;;-1:-1:-1;;;2111:68:0;;14883:2:1;2111:68:0;;;14865:21:1;;;14902:18;;;14895:30;14961:34;14941:18;;;14934:62;15013:18;;2111:68:0;14855:182:1;49630:551:0;49683:7;49706:11;49718:14;49733:11;49748:21;49763:5;49748:14;:21::i;:::-;-1:-1:-1;;;;;49806:17:0;;49787:16;49806:17;;;:10;:17;;;;;;;;;49828:22;;;:28;;;49889:16;;;;49872:45;;18599:25:1;;;18640:18;;;18633:34;;;18683:18;;;18676:34;;;49828:28:0;;-1:-1:-1;49705:64:0;;-1:-1:-1;49705:64:0;;-1:-1:-1;49806:17:0;;49872:45;;18587:2:1;18572:18;49872:45:0;;;;;;;49941:31;49966:5;49941:24;:31::i;:::-;49922:16;;;:50;49995:9;;;;:30;;50021:3;;49995:21;;50009:6;49995:13;:21::i;:30::-;49983:9;;;:42;50052:13;;;;:25;;50070:6;50052:17;:25::i;:::-;50036:13;;;:41;-1:-1:-1;;;;;50112:14:0;;;;;;:7;:14;;;;;:21;;;:30;;50138:3;50112:25;:30::i;:::-;-1:-1:-1;;;;;50088:14:0;;;;;;;:7;:14;;;;;:21;;:54;;;;-1:-1:-1;50170:3:0;;49630:551;-1:-1:-1;;;49630:551:0:o;38775:248::-;38919:96;38939:5;38969:27;;;38998:4;39004:2;39008:5;38946:68;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;38946:68:0;;;;;;;;;;;;;;-1:-1:-1;;;;;38946:68:0;-1:-1:-1;;;;;;38946:68:0;;;;;;;;;;38919:19;:96::i;:::-;38775:248;;;;:::o;11541:98::-;11599:7;11626:5;11630:1;11626;:5;:::i;11160:98::-;11218:7;11245:5;11249:1;11245;:5;:::i;11898:98::-;11956:7;11983:5;11987:1;11983;:5;:::i;12297:98::-;12355:7;12382:5;12386:1;12382;:5;:::i;54473:442::-;54553:10;54527:13;54543:21;;;:9;:21;;;;;;54586:12;:19;54543:21;;54610:301;54634:6;54630:1;:10;54610:301;;;54653:13;54669:12;54682:1;54669:15;;;;;;-1:-1:-1;;;54669:15:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;54669:15:0;;-1:-1:-1;54704:18:0;54669:15;54704:11;:18::i;:::-;54690:32;-1:-1:-1;;;;;;54734:24:0;;54753:4;54734:24;54730:176;;54813:35;54821:7;54830:5;54837;54844:3;54813:7;:35::i;:::-;-1:-1:-1;;;;;54767:20:0;;;;;;;:11;:20;;;;;;;;:27;;;;;;;;;;;;:43;;:81;;;;54855:31;;;:22;:31;;;;;:38;;;;;;;:44;;;54730:176;54610:301;;54642:3;;;;;:::i;:::-;;;;54610:301;;53219:755;53320:20;;53303:14;53345:625;53365:6;53361:1;:10;53345:625;;;53384:13;53400;53414:1;53400:16;;;;;;-1:-1:-1;;;53400:16:0;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;53439:18:0;;;53422:14;53439:18;;;:11;:18;;;;;;:25;;;;;;;;;;;;:41;;;53400:16;;-1:-1:-1;53490:10:0;;53486:479;;53584:160;;;;;;;;-1:-1:-1;;;;;53633:18:0;;;-1:-1:-1;53633:18:0;;;:11;:18;;;;;;;:25;;;;;;;;;;;;;:39;53584:160;;53633:51;;53677:6;53633:43;:51::i;:::-;53584:160;;53723:1;53584:160;;;;;;;-1:-1:-1;;;;;53556:18:0;;;;;:11;:18;;;;;;:25;;;;;;;;;;;:188;;;;;;;;;;;;;;;;53788:10;:17;;;;:25;;;53779:34;;:75;;53853:1;53779:75;;;-1:-1:-1;;;;;53815:17:0;;;;;;:10;:17;;;;;:25;;;:37;;53845:6;53815:29;:37::i;:::-;-1:-1:-1;;;;;53751:17:0;;;;;;:10;:17;;;;;:25;;:103;;;;53873:41;;53900:5;53907:6;53873:26;:41::i;:::-;53944:5;-1:-1:-1;;;;;53926:32:0;53937:5;-1:-1:-1;;;;;53926:32:0;;53951:6;53926:32;;;;18108:25:1;;18096:2;18081:18;;18063:76;53926:32:0;;;;;;;;53486:479;53345:625;;53373:3;;;;;:::i;:::-;;;;53345:625;;3157:191;3231:16;3250:6;;-1:-1:-1;;;;;3267:17:0;;;-1:-1:-1;;;;;;3267:17:0;;;;;;3300:40;;3250:6;;;;;;;3300:40;;3231:16;3300:40;3157:191;;:::o;38556:211::-;38700:58;;-1:-1:-1;;;;;6547:32:1;;38700:58:0;;;6529:51:1;6596:18;;;6589:34;;;38673:86:0;;38693:5;;-1:-1:-1;;;38723:23:0;6502:18:1;;38700:58:0;6484:145:1;56902:401:0;57021:45;;-1:-1:-1;;;57021:45:0;;57060:4;57021:45;;;5913:51:1;57002:16:0;;-1:-1:-1;;;;;57021:30:0;;;;;5886:18:1;;57021:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57002:64;;57091:8;57081:7;:18;57077:121;;;57120:12;;57116:71;;57163:8;57153:18;;57116:71;57211:9;;57208:88;;57237:47;-1:-1:-1;;;;;57237:33:0;;57271:3;57276:7;57237:33;:47::i;48630:860::-;48768:12;;48725:20;;;48791:692;48809:3;48807:1;:5;48791:692;;;48832:13;48848:8;48857:1;48848:11;;;;;;-1:-1:-1;;;48848:11:0;;;;;;;;;;;;;;;48832:27;;48874:25;48916:5;48902:20;;;;;;-1:-1:-1;;;48902:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48902:20:0;;48874:48;;48965:9;48961:172;48980:5;48978:1;:7;48961:172;;;49053:10;49009:15;49044:20;;;:8;:20;;;;;49065:8;;49027:50;;49044:20;49009:15;;49065:5;;49071:1;;49065:8;;;;-1:-1:-1;;;49065:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;49044:30:0;-1:-1:-1;;;;;49044:30:0;;;;;;;;;;;;49075:1;49027:16;:50::i;:::-;49009:68;;49110:7;49096:8;49105:1;49096:11;;;;;;-1:-1:-1;;;49096:11:0;;;;;;;;;;;;;;;;;;:21;-1:-1:-1;48986:3:0;;;;:::i;:::-;;;;48961:172;;;;49174:9;49170:266;49188:5;49186:1;:7;49170:266;;;49217:15;49235:8;49244:1;49235:11;;;;;;-1:-1:-1;;;49235:11:0;;;;;;;;;;;;;;;49217:29;;49273:5;49279:1;49273:8;;;;;;-1:-1:-1;;;49273:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;49265:30:0;;49304:4;49319:10;49332:7;49265:75;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;49389:10:0;49380:20;;;;:8;:20;;;;;49401:8;;49359:61;;-1:-1:-1;49380:20:0;;-1:-1:-1;49401:5:0;;49407:1;;49401:8;;;;-1:-1:-1;;;49401:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;49380:30:0;-1:-1:-1;;;;;49380:30:0;;;;;;;;;;;;49412:7;49359:20;:61::i;:::-;;49170:266;49194:3;;;;;:::i;:::-;;;;49170:266;;;-1:-1:-1;49450:21:0;49466:5;49450:21;;:::i;:::-;;;48791:692;;48813:3;;;;;:::i;:::-;;;;48791:692;;;;48630:860;;;;;:::o;54024:394::-;-1:-1:-1;;;;;54199:18:0;;;54165:16;54199:18;;;:11;:18;;;;;;;;:32;;;;;;;;;;;;:48;;;54297:29;;;:22;:29;;;;;:43;;;;;;;;;;54199:48;;54165:16;54270:71;;:22;;:26;:71::i;:::-;54252:89;-1:-1:-1;54357:56:0;54370:42;42902:4;54370:19;:6;54252:89;54370:10;:19::i;:42::-;54357:8;;:12;:56::i;:::-;54346:67;54024:394;-1:-1:-1;;;;;;54024:394:0:o;46872:653::-;46970:20;47026:9;:16;47010:5;:12;:32;47002:58;;;;-1:-1:-1;;;47002:58:0;;13857:2:1;47002:58:0;;;13839:21:1;13896:2;13876:18;;;13869:30;-1:-1:-1;;;13915:18:1;;;13908:44;13969:18;;47002:58:0;13829:164:1;47002:58:0;-1:-1:-1;47086:12:0;;47114:9;47109:166;47133:12;47129:1;:16;47109:166;;;47207:10;47198:20;;;;:8;:20;;;;;47219:8;;47175:68;;47198:20;47219:5;;47225:1;;47219:8;;;;-1:-1:-1;;;47219:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;47198:30:0;-1:-1:-1;;;;;47198:30:0;;;;;;;;;;;;47230:9;47240:1;47230:12;;;;;;-1:-1:-1;;;47230:12:0;;;;;;;;;;;;;;;47175:22;:68::i;:::-;47167:95;;;;-1:-1:-1;;;47167:95:0;;11388:2:1;47167:95:0;;;11370:21:1;11427:2;11407:18;;;11400:30;-1:-1:-1;;;11446:18:1;;;11439:45;11501:18;;47167:95:0;11360:165:1;47167:95:0;47147:3;;;;:::i;:::-;;;;47109:166;;;;47291:9;47287:223;47305:12;47303:1;:14;47287:223;;;47345:5;47351:1;47345:8;;;;;;-1:-1:-1;;;47345:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;47337:30:0;;47376:4;47391:10;47404:9;47414:1;47404:12;;;;;;-1:-1:-1;;;47404:12:0;;;;;;;;;;;;;;;47337:80;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;47462:10:0;47453:20;;;;:8;:20;;;;;47474:8;;47432:66;;-1:-1:-1;47453:20:0;;-1:-1:-1;47474:5:0;;47480:1;;47474:8;;;;-1:-1:-1;;;47474:8:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;47453:30:0;-1:-1:-1;;;;;47453:30:0;;;;;;;;;;;;47485:9;47495:1;47485:12;;;;;;-1:-1:-1;;;47485:12:0;;;;;;;;;;;;;;;47432:20;:66::i;:::-;-1:-1:-1;47318:3:0;;;;:::i;:::-;;;;47287:223;;;;46872:653;;;;:::o;30026:131::-;30093:4;30117:32;30122:3;30142:5;30117:4;:32::i;51664:271::-;-1:-1:-1;;;;;51858:24:0;;51728:14;51858:24;;;:10;:24;;;;;:40;;;;51807:39;;;;;51764:163;;42902:4;;51764:140;;51858:40;51764:83;;:38;51869:12;51764:24;:38::i;27765:120::-;27832:7;27859:3;:11;;27871:5;27859:18;;;;;;-1:-1:-1;;;27859:18:0;;;;;;;;;;;;;;;;;27852:25;;27765:120;;;;:::o;41623:716::-;42047:23;42073:69;42101:4;42073:69;;;;;;;;;;;;;;;;;42081:5;-1:-1:-1;;;;;42073:27:0;;;:69;;;;;:::i;:::-;42157:17;;42047:95;;-1:-1:-1;42157:21:0;42153:179;;42254:10;42243:30;;;;;;;;;;;;:::i;:::-;42235:85;;;;-1:-1:-1;;;42235:85:0;;17393:2:1;42235:85:0;;;17375:21:1;17432:2;17412:18;;;17405:30;17471:34;17451:18;;;17444:62;-1:-1:-1;;;17522:18:1;;;17515:40;17572:19;;42235:85:0;17365:232:1;30333:137:0;30403:4;30427:35;30435:3;30455:5;30427:7;:35::i;30556:146::-;30633:4;27184:19;;;:12;;;:19;;;;;;:24;;30657:37;27087:129;24974:414;25037:4;27184:19;;;:12;;;:19;;;;;;25054:327;;-1:-1:-1;25097:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;25280:18;;25258:19;;;:12;;;:19;;;;;;:40;;;;25313:11;;25054:327;-1:-1:-1;25364:5:0;25357:12;;19490:229;19627:12;19659:52;19681:6;19689:4;19695:1;19698:12;19659:21;:52::i;:::-;19652:59;19490:229;-1:-1:-1;;;;19490:229:0:o;25564:1437::-;25630:4;25769:19;;;:12;;;:19;;;;;;25805:15;;25801:1193;;26180:21;26204:14;26217:1;26204:10;:14;:::i;:::-;26253:18;;26180:38;;-1:-1:-1;26233:17:0;;26253:22;;26274:1;;26253:22;:::i;:::-;26233:42;;26309:13;26296:9;:26;26292:422;;26343:17;26363:3;:11;;26375:9;26363:22;;;;;;-1:-1:-1;;;26363:22:0;;;;;;;;;;;;;;;;;26343:42;;26517:9;26488:3;:11;;26500:13;26488:26;;;;;;-1:-1:-1;;;26488:26:0;;;;;;;;;;;;;;;;;;;;:38;;;;26602:23;;;:12;;;:23;;;;;:36;;;26292:422;26795:17;;:3;;:17;;;-1:-1:-1;;;26795:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;26890:3;:12;;:19;26903:5;26890:19;;;;;;;;;;;26883:26;;;26933:4;26926:11;;;;;;;25801:1193;26977:5;26970:12;;;;;20610:510;20780:12;20838:5;20813:21;:30;;20805:81;;;;-1:-1:-1;;;20805:81:0;;12077:2:1;20805:81:0;;;12059:21:1;12116:2;12096:18;;;12089:30;12155:34;12135:18;;;12128:62;-1:-1:-1;;;12206:18:1;;;12199:36;12252:19;;20805:81:0;12049:228:1;20805:81:0;-1:-1:-1;;;;;17040:19:0;;;20897:60;;;;-1:-1:-1;;;20897:60:0;;16683:2:1;20897:60:0;;;16665:21:1;16722:2;16702:18;;;16695:30;16761:31;16741:18;;;16734:59;16810:18;;20897:60:0;16655:179:1;20897:60:0;20971:12;20985:23;21012:6;-1:-1:-1;;;;;21012:11:0;21031:5;21038:4;21012:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20970:73;;;;21061:51;21078:7;21087:10;21099:12;21061:16;:51::i;:::-;21054:58;20610:510;-1:-1:-1;;;;;;;20610:510:0:o;23296:762::-;23446:12;23475:7;23471:580;;;-1:-1:-1;23506:10:0;23499:17;;23471:580;23620:17;;:21;23616:424;;23868:10;23862:17;23929:15;23916:10;23912:2;23908:19;23901:44;23816:148;24011:12;24004:20;;-1:-1:-1;;;24004:20:0;;;;;;;;:::i;14:173:1:-;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:2;;177:1;174;167:12;111:2;63:124;;;:::o;192:693::-;246:5;299:3;292:4;284:6;280:17;276:27;266:2;;321:5;314;307:20;266:2;361:6;348:20;387:4;411:60;427:43;467:2;427:43;:::i;:::-;411:60;:::i;:::-;493:3;517:2;512:3;505:15;545:2;540:3;536:12;529:19;;580:2;572:6;568:15;632:3;627:2;621;618:1;614:10;606:6;602:23;598:32;595:41;592:2;;;653:5;646;639:20;592:2;679:5;693:163;707:2;704:1;701:9;693:163;;;764:17;;752:30;;802:12;;;;834;;;;725:1;718:9;693:163;;;-1:-1:-1;874:5:1;;256:629;-1:-1:-1;;;;;;;256:629:1:o;890:196::-;949:6;1002:2;990:9;981:7;977:23;973:32;970:2;;;1023:6;1015;1008:22;970:2;1051:29;1070:9;1051:29;:::i;1091:270::-;1159:6;1167;1220:2;1208:9;1199:7;1195:23;1191:32;1188:2;;;1241:6;1233;1226:22;1188:2;1269:29;1288:9;1269:29;:::i;:::-;1259:39;;1317:38;1351:2;1340:9;1336:18;1317:38;:::i;:::-;1307:48;;1178:183;;;;;:::o;1366:858::-;1463:6;1471;1479;1487;1495;1548:3;1536:9;1527:7;1523:23;1519:33;1516:2;;;1570:6;1562;1555:22;1516:2;1598:29;1617:9;1598:29;:::i;:::-;1588:39;;1646:38;1680:2;1669:9;1665:18;1646:38;:::i;:::-;1636:48;;1731:2;1720:9;1716:18;1703:32;1693:42;;1786:2;1775:9;1771:18;1758:32;1809:18;1850:2;1842:6;1839:14;1836:2;;;1871:6;1863;1856:22;1836:2;1914:6;1903:9;1899:22;1889:32;;1959:7;1952:4;1948:2;1944:13;1940:27;1930:2;;1986:6;1978;1971:22;1930:2;2031;2018:16;2057:2;2049:6;2046:14;2043:2;;;2078:6;2070;2063:22;2043:2;2128:7;2123:2;2114:6;2110:2;2106:15;2102:24;2099:37;2096:2;;;2154:6;2146;2139:22;2096:2;1506:718;;;;-1:-1:-1;1506:718:1;;-1:-1:-1;2190:2:1;2182:11;;2212:6;1506:718;-1:-1:-1;;;1506:718:1:o;2229:264::-;2297:6;2305;2358:2;2346:9;2337:7;2333:23;2329:32;2326:2;;;2379:6;2371;2364:22;2326:2;2407:29;2426:9;2407:29;:::i;:::-;2397:39;2483:2;2468:18;;;;2455:32;;-1:-1:-1;;;2316:177:1:o;2498:332::-;2575:6;2583;2591;2644:2;2632:9;2623:7;2619:23;2615:32;2612:2;;;2665:6;2657;2650:22;2612:2;2693:29;2712:9;2693:29;:::i;:::-;2683:39;2769:2;2754:18;;2741:32;;-1:-1:-1;2820:2:1;2805:18;;;2792:32;;2602:228;-1:-1:-1;;;2602:228:1:o;2835:1212::-;2953:6;2961;3014:2;3002:9;2993:7;2989:23;2985:32;2982:2;;;3035:6;3027;3020:22;2982:2;3080:9;3067:23;3109:18;3150:2;3142:6;3139:14;3136:2;;;3171:6;3163;3156:22;3136:2;3214:6;3203:9;3199:22;3189:32;;3259:7;3252:4;3248:2;3244:13;3240:27;3230:2;;3286:6;3278;3271:22;3230:2;3327;3314:16;3349:4;3373:60;3389:43;3429:2;3389:43;:::i;3373:60::-;3455:3;3479:2;3474:3;3467:15;3507:2;3502:3;3498:12;3491:19;;3538:2;3534;3530:11;3586:7;3581:2;3575;3572:1;3568:10;3564:2;3560:19;3556:28;3553:41;3550:2;;;3612:6;3604;3597:22;3550:2;3639:6;3630:15;;3654:169;3668:2;3665:1;3662:9;3654:169;;;3725:23;3744:3;3725:23;:::i;:::-;3713:36;;3686:1;3679:9;;;;;3769:12;;;;3801;;3654:169;;;-1:-1:-1;3842:5:1;-1:-1:-1;;3885:18:1;;3872:32;;-1:-1:-1;;3916:16:1;;;3913:2;;;3950:6;3942;3935:22;3913:2;;3978:63;4033:7;4022:8;4011:9;4007:24;3978:63;:::i;:::-;3968:73;;;2972:1075;;;;;:::o;4052:297::-;4119:6;4172:2;4160:9;4151:7;4147:23;4143:32;4140:2;;;4193:6;4185;4178:22;4140:2;4230:9;4224:16;4283:5;4276:13;4269:21;4262:5;4259:32;4249:2;;4310:6;4302;4295:22;4354:190;4413:6;4466:2;4454:9;4445:7;4441:23;4437:32;4434:2;;;4487:6;4479;4472:22;4434:2;-1:-1:-1;4515:23:1;;4424:120;-1:-1:-1;4424:120:1:o;4549:194::-;4619:6;4672:2;4660:9;4651:7;4647:23;4643:32;4640:2;;;4693:6;4685;4678:22;4640:2;-1:-1:-1;4721:16:1;;4630:113;-1:-1:-1;4630:113:1:o;4748:293::-;4816:6;4869:2;4857:9;4848:7;4844:23;4840:32;4837:2;;;4890:6;4882;4875:22;4837:2;4927:9;4921:16;4977:4;4970:5;4966:16;4959:5;4956:27;4946:2;;5002:6;4994;4987:22;5046:437;5099:3;5137:5;5131:12;5164:6;5159:3;5152:19;5190:4;5219:2;5214:3;5210:12;5203:19;;5256:2;5249:5;5245:14;5277:3;5289:169;5303:6;5300:1;5297:13;5289:169;;;5364:13;;5352:26;;5398:12;;;;5433:15;;;;5325:1;5318:9;5289:169;;;-1:-1:-1;5474:3:1;;5107:376;-1:-1:-1;;;;;5107:376:1:o;5488:274::-;5617:3;5655:6;5649:13;5671:53;5717:6;5712:3;5705:4;5697:6;5693:17;5671:53;:::i;:::-;5740:16;;;;;5625:137;-1:-1:-1;;5625:137:1:o;5975:375::-;-1:-1:-1;;;;;6233:15:1;;;6215:34;;6285:15;;;;6280:2;6265:18;;6258:43;6332:2;6317:18;;6310:34;;;;6165:2;6150:18;;6132:218::o;6634:835::-;6902:2;6914:21;;;6984:13;;6887:18;;;7006:22;;;6854:4;;7081;;7059:2;7044:18;;;7108:15;;;6854:4;7154:195;7168:6;7165:1;7162:13;7154:195;;;7233:13;;-1:-1:-1;;;;;7229:39:1;7217:52;;7289:12;;;;7324:15;;;;7265:1;7183:9;7154:195;;;7158:3;;;7394:9;7389:3;7385:19;7380:2;7369:9;7365:18;7358:47;7422:41;7459:3;7451:6;7422:41;:::i;7474:878::-;7701:2;7753:21;;;7823:13;;7726:18;;;7845:22;;;7672:4;;7701:2;7886;;7904:18;;;;7945:15;;;7672:4;7991:335;8005:6;8002:1;7999:13;7991:335;;;8064:13;;8106:9;;-1:-1:-1;;;;;8102:35:1;8090:48;;8178:11;;;8172:18;8158:12;;;8151:40;8231:11;;8225:18;8211:12;;;8204:40;8273:4;8264:14;;;;8301:15;;;;8134:1;8020:9;7991:335;;;-1:-1:-1;8343:3:1;;7681:671;-1:-1:-1;;;;;;;7681:671:1:o;8357:261::-;8536:2;8525:9;8518:21;8499:4;8556:56;8608:2;8597:9;8593:18;8585:6;8556:56;:::i;9022:383::-;9171:2;9160:9;9153:21;9134:4;9203:6;9197:13;9246:6;9241:2;9230:9;9226:18;9219:34;9262:66;9321:6;9316:2;9305:9;9301:18;9296:2;9288:6;9284:15;9262:66;:::i;:::-;9389:2;9368:15;-1:-1:-1;;9364:29:1;9349:45;;;;9396:2;9345:54;;9143:262;-1:-1:-1;;9143:262:1:o;15042:340::-;15244:2;15226:21;;;15283:2;15263:18;;;15256:30;-1:-1:-1;;;15317:2:1;15302:18;;15295:46;15373:2;15358:18;;15216:166::o;19261:275::-;19332:2;19326:9;19397:2;19378:13;;-1:-1:-1;;19374:27:1;19362:40;;19432:18;19417:34;;19453:22;;;19414:62;19411:2;;;19479:18;;:::i;:::-;19515:2;19508:22;19306:230;;-1:-1:-1;19306:230:1:o;19541:183::-;19601:4;19634:18;19626:6;19623:30;19620:2;;;19656:18;;:::i;:::-;-1:-1:-1;19701:1:1;19697:14;19713:4;19693:25;;19610:114::o;19729:128::-;19769:3;19800:1;19796:6;19793:1;19790:13;19787:2;;;19806:18;;:::i;:::-;-1:-1:-1;19842:9:1;;19777:80::o;19862:217::-;19902:1;19928;19918:2;;-1:-1:-1;;;19953:31:1;;20007:4;20004:1;19997:15;20035:4;19960:1;20025:15;19918:2;-1:-1:-1;20064:9:1;;19908:171::o;20084:422::-;20173:1;20216:5;20173:1;20230:270;20251:7;20241:8;20238:21;20230:270;;;20310:4;20306:1;20302:6;20298:17;20292:4;20289:27;20286:2;;;20319:18;;:::i;:::-;20369:7;20359:8;20355:22;20352:2;;;20389:16;;;;20352:2;20468:22;;;;20428:15;;;;20230:270;;;20234:3;20148:358;;;;;:::o;20511:140::-;20569:5;20598:47;20639:4;20629:8;20625:19;20619:4;20705:5;20735:8;20725:2;;-1:-1:-1;20776:1:1;20790:5;;20725:2;20824:4;20814:2;;-1:-1:-1;20861:1:1;20875:5;;20814:2;20906:4;20924:1;20919:59;;;;20992:1;20987:130;;;;20899:218;;20919:59;20949:1;20940:10;;20963:5;;;20987:130;21024:3;21014:8;21011:17;21008:2;;;21031:18;;:::i;:::-;-1:-1:-1;;21087:1:1;21073:16;;21102:5;;20899:218;;21201:2;21191:8;21188:16;21182:3;21176:4;21173:13;21169:36;21163:2;21153:8;21150:16;21145:2;21139:4;21136:12;21132:35;21129:77;21126:2;;;-1:-1:-1;21238:19:1;;;21270:5;;21126:2;21317:34;21342:8;21336:4;21317:34;:::i;:::-;21387:6;21383:1;21379:6;21375:19;21366:7;21363:32;21360:2;;;21398:18;;:::i;:::-;21436:20;;20715:747;-1:-1:-1;;;20715:747:1:o;21467:168::-;21507:7;21573:1;21569;21565:6;21561:14;21558:1;21555:21;21550:1;21543:9;21536:17;21532:45;21529:2;;;21580:18;;:::i;:::-;-1:-1:-1;21620:9:1;;21519:116::o;21640:125::-;21680:4;21708:1;21705;21702:8;21699:2;;;21713:18;;:::i;:::-;-1:-1:-1;21750:9:1;;21689:76::o;21770:258::-;21842:1;21852:113;21866:6;21863:1;21860:13;21852:113;;;21942:11;;;21936:18;21923:11;;;21916:39;21888:2;21881:10;21852:113;;;21983:6;21980:1;21977:13;21974:2;;;-1:-1:-1;;22018:1:1;22000:16;;21993:27;21823:205::o;22033:135::-;22072:3;-1:-1:-1;;22093:17:1;;22090:2;;;22113:18;;:::i;:::-;-1:-1:-1;22160:1:1;22149:13;;22080:88::o;22173:127::-;22234:10;22229:3;22225:20;22222:1;22215:31;22265:4;22262:1;22255:15;22289:4;22286:1;22279:15;22305:127;22366:10;22361:3;22357:20;22354:1;22347:31;22397:4;22394:1;22387:15;22421:4;22418:1;22411:15

ipfs://b4749a5b34caa2ed0a80725373dec952c85d9bfdc72daa0fd0a59cd8e2f101cf