Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
• 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(Bytes32Set storage set, ...
•    - function remove(Bytes32Set storage se ...
•    - function contains(Bytes32Set storage ...
•    - function length(Bytes32Set storage se ...
•    - function at(Bytes32Set storage set, u ...
•    - function values(Bytes32Set storage se ...
•    - 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 IERC721Receiver
•    - function onERC721Received(
• interface IERC165
•    - function supportsInterface(bytes4 int ...
• interface IERC721 is IERC165
•    - function balanceOf(address owner)
•    - function ownerOf(uint256 tokenId)
•    - function safeTransferFrom(
•    - function transferFrom(
•    - function approve(address to, uint256 ...
•    - function getApproved(uint256 tokenId)
•    - function setApprovalForAll(address op ...
•    - function isApprovedForAll(address own ...
•    - function safeTransferFrom(
• interface IERC721Enumerable is IERC72 ...
•    - function totalSupply()
•    - function tokenOfOwnerByIndex(address ...
•    - function tokenByIndex(uint256 index)
• 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 _msgSender()
•    - function _msgData()
•    - function paused()
•    - function _pause()
•    - function _unpause()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
•  contract BearStaking is Ownable, I ... *
•    - function pause()
•    - function unpause()
•    - function setRate(uint256 _rate)
•    - function setExpiration(uint256 _expir ...
•    - function stakesOf(address account)
•    - function calculateRewards(address acc ...
•    - function calculateReward(address acco ...
•    - function claimRewards(uint256[] calld ...
•    - function stake(uint256[] calldata tok ...
•    - function unstake(uint256[] calldata t ...
•    - function unstakeWithoutClaiming(uint2 ...
•    - function withdrawHoney()
•    - function onERC721Received(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-02-13
*/

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Moves `amount` tokens from the caller's account to `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);

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

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a / b + (a % b == 0 ? 0 : 1);
    }
}

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
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;
    }
}

// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol


// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
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;
    }

    // Bytes32Set

    struct Bytes32Set {
        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(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, 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(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

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

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set 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(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _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(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        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(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(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(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

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

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet 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(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(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(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;
    }
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol


// OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.0 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol


// OpenZeppelin Contracts v4.4.0 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


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

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

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

// File: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
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;
        }
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.0 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/security/Pausable.sol


// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)

pragma solidity ^0.8.0;


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

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

    bool private _paused;

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

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

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

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

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

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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

// File: contracts/BearStaking2.sol


pragma solidity ^0.8.0;










contract BearStaking is Ownable, IERC721Receiver, ReentrancyGuard, Pausable {
    using EnumerableSet for EnumerableSet.UintSet; 
    
    // Contract address for Baller Bears
    address public bearsAddress;
    // Contract address for honey
    address public honeyAddress;

    // Block to stop earning honey
    uint256 public expiration; 
    // How often honey is earned
    uint256 public rate; 
  
    mapping(address => EnumerableSet.UintSet) private _stakes;
    mapping(address => mapping(uint256 => uint256)) public _stakeBlocks;

    constructor(
      address _bearsAddress,
      uint256 _rate,
      uint256 _expiration,
      address _honeyAddress
    ) {
        bearsAddress = _bearsAddress;
        rate = _rate;
        expiration = block.number + _expiration;
        honeyAddress = _honeyAddress;
        _pause();
    }

    // Pause the contract
    function pause() public onlyOwner {
        _pause();
    }
    // Unpause the contract
    function unpause() public onlyOwner {
        _unpause();
    }

///////////////////////
// STAKING MECHANICS //
///////////////////////

    // Set the rate honey is earned
    function setRate(uint256 _rate) public onlyOwner() {
      rate = _rate;
    }
    // Set the block honey stops being earned
    function setExpiration(uint256 _expiration) public onlyOwner() {
      expiration = block.number + _expiration;
    }

    // Check what Bears a wallet has staked
    function stakesOf(address account)
      external 
      view 
      returns (uint256[] memory) {
      EnumerableSet.UintSet storage stakeSet = _stakes[account];
      uint256[] memory tokenIds = new uint256[] (stakeSet.length());

      for (uint256 i; i < stakeSet.length(); i++) {
        tokenIds[i] = stakeSet.at(i);
      }

      return tokenIds;
    }

    // Check how much honey you have to claim for multiple Bears
    function calculateRewards(address account, uint256[] memory tokenIds) 
      public 
      view 
      returns (uint256[] memory rewards) 
    {
      rewards = new uint256[](tokenIds.length);

      for (uint256 i; i < tokenIds.length; i++) {
        uint256 tokenId = tokenIds[i];

        rewards[i] = 
          rate * 
          (_stakes[account].contains(tokenId) ? 1 : 0) * 
          (Math.min(block.number, expiration) - 
            _stakeBlocks[account][tokenId]);
      }

      return rewards;
    }

    // Check how much honey you have to claim for one Bear
    function calculateReward(address account, uint256 tokenId) 
      public 
      view 
      returns (uint256) {
      require(Math.min(block.number, expiration) > _stakeBlocks[account][tokenId], "Invalid blocks");
      return rate * 
          (_stakes[account].contains(tokenId) ? 1 : 0) * 
          (Math.min(block.number, expiration) - 
            _stakeBlocks[account][tokenId]);
    }

    // Claim rewards for specified Bears
    function claimRewards(uint256[] calldata tokenIds) public whenNotPaused {
      uint256 reward; 
      uint256 blockCur = Math.min(block.number, expiration);

      for (uint256 i; i < tokenIds.length; i++) {
        reward += calculateReward(msg.sender, tokenIds[i]);
        _stakeBlocks[msg.sender][tokenIds[i]] = blockCur;
      }

      if (reward > 0) {
        IERC20(honeyAddress).transfer(msg.sender, reward);
      }
    }

    // Stake Bears
    function stake(uint256[] calldata tokenIds) external whenNotPaused {
        require(msg.sender != bearsAddress, "Invalid address");
        claimRewards(tokenIds);

        for (uint256 i; i < tokenIds.length; i++) {
            IERC721(bearsAddress).safeTransferFrom(
                msg.sender,
                address(this),
                tokenIds[i],
                ""
            );

            _stakes[msg.sender].add(tokenIds[i]);
        }
    }

    // Unstake Bears and claim honey
    function unstake(uint256[] calldata tokenIds) external whenNotPaused nonReentrant() {
        claimRewards(tokenIds);

        for (uint256 i; i < tokenIds.length; i++) {
            require(
                _stakes[msg.sender].contains(tokenIds[i]),
                "That Bear is not staked."
            );

            _stakes[msg.sender].remove(tokenIds[i]);

            IERC721(bearsAddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIds[i],
                ""
            );
        }
    }

    // Unstake Bears without claiming honey
    function unstakeWithoutClaiming(uint256[] calldata tokenIds) external whenNotPaused nonReentrant() {
        for (uint256 i; i < tokenIds.length; i++) {
            require(
                _stakes[msg.sender].contains(tokenIds[i]),
                "That Bear is not staked."
            );

            _stakes[msg.sender].remove(tokenIds[i]);

            IERC721(bearsAddress).safeTransferFrom(
                address(this),
                msg.sender,
                tokenIds[i],
                ""
            );
        }
    }

    // Pull honey out of the contract (owner only)
    function withdrawHoney() external onlyOwner {
        uint256 tokenSupply = IERC20(honeyAddress).balanceOf(address(this));
        IERC20(honeyAddress).transfer(msg.sender, tokenSupply);
    }

    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_bearsAddress","type":"address"},{"internalType":"uint256","name":"_rate","type":"uint256"},{"internalType":"uint256","name":"_expiration","type":"uint256"},{"internalType":"address","name":"_honeyAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"_stakeBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bearsAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"calculateReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"calculateRewards","outputs":[{"internalType":"uint256[]","name":"rewards","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"claimRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"expiration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"honeyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","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":"pure","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_expiration","type":"uint256"}],"name":"setExpiration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rate","type":"uint256"}],"name":"setRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"stakesOf","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"unstakeWithoutClaiming","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawHoney","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040523480156200001157600080fd5b5060405162002e0d38038062002e0d8339818101604052810190620000379190620002f9565b620000576200004b6200013060201b60201c565b6200013860201b60201c565b600180819055506000600260006101000a81548160ff02191690831515021790555083600260016101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550826005819055508143620000cf9190620003f3565b60048190555080600360006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555062000126620001fc60201b60201c565b505050506200051f565b600033905090565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b6200020c620002b460201b60201c565b156200024f576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016200024690620003c0565b60405180910390fd5b6001600260006101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586200029b6200013060201b60201c565b604051620002aa9190620003a3565b60405180910390a1565b6000600260009054906101000a900460ff16905090565b600081519050620002dc81620004eb565b92915050565b600081519050620002f38162000505565b92915050565b60008060008060808587031215620003165762000315620004bd565b5b60006200032687828801620002cb565b94505060206200033987828801620002e2565b93505060406200034c87828801620002e2565b92505060606200035f87828801620002cb565b91505092959194509250565b620003768162000450565b82525050565b60006200038b601083620003e2565b91506200039882620004c2565b602082019050919050565b6000602082019050620003ba60008301846200036b565b92915050565b60006020820190508181036000830152620003db816200037c565b9050919050565b600082825260208201905092915050565b6000620004008262000484565b91506200040d8362000484565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156200044557620004446200048e565b5b828201905092915050565b60006200045d8262000464565b9050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b600080fd5b7f5061757361626c653a2070617573656400000000000000000000000000000000600082015250565b620004f68162000450565b81146200050257600080fd5b50565b620005108162000484565b81146200051c57600080fd5b50565b6128de806200052f6000396000f3fe608060405234801561001057600080fd5b50600436106101425760003560e01c80634665096d116100b85780638456cb591161007c5780638456cb59146103295780638da5cb5b14610333578063b3d8d07914610351578063b44b71001461036f578063e449f3411461039f578063f2fde38b146103bb57610142565b80634665096d146102ab578063515a20ba146102c95780635c975abb146102e55780635eac623914610303578063715018a61461031f57610142565b80631852e8d91161010a5780631852e8d9146101fd5780632c4e722e1461022d57806333b69c4c1461024b57806334e361a11461027b57806334fcf437146102855780633f4ba83a146102a157610142565b8063021c1b4a14610147578063068c526f146101635780630c130269146101935780630fbf0a93146101b1578063150b7a02146101cd575b600080fd5b610161600480360381019061015c9190611ebd565b6103d7565b005b61017d60048036038101906101789190611e21565b610658565b60405161018a919061221b565b60405180910390f35b61019b6107eb565b6040516101a8919061218d565b60405180910390f35b6101cb60048036038101906101c69190611ebd565b610811565b005b6101e760048036038101906101e29190611d99565b610a2f565b6040516101f49190612258565b60405180910390f35b61021760048036038101906102129190611e7d565b610a44565b6040516102249190612373565b60405180910390f35b610235610bcb565b6040516102429190612373565b60405180910390f35b61026560048036038101906102609190611d6c565b610bd1565b604051610272919061221b565b60405180910390f35b610283610cce565b005b61029f600480360381019061029a9190611f37565b610eac565b005b6102a9610f32565b005b6102b3610fb8565b6040516102c09190612373565b60405180910390f35b6102e360048036038101906102de9190611f37565b610fbe565b005b6102ed61104f565b6040516102fa919061223d565b60405180910390f35b61031d60048036038101906103189190611ebd565b611066565b005b61032761123f565b005b6103316112c7565b005b61033b61134d565b604051610348919061218d565b60405180910390f35b610359611376565b604051610366919061218d565b60405180910390f35b61038960048036038101906103849190611e7d565b61139c565b6040516103969190612373565b60405180910390f35b6103b960048036038101906103b49190611ebd565b6113c1565b005b6103d560048036038101906103d09190611d6c565b61164c565b005b6103df61104f565b1561041f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610416906122d3565b60405180910390fd5b60026001541415610465576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161045c90612333565b60405180910390fd5b600260018190555060005b8282905081101561064c576104e58383838181106104915761049061266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061174490919063ffffffff16565b610524576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161051b90612313565b60405180910390fd5b61058e83838381811061053a5761053961266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061175e90919063ffffffff16565b50600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b88d4fde30338686868181106105e2576105e161266a565b5b905060200201356040518463ffffffff1660e01b8152600401610607939291906121a8565b600060405180830381600087803b15801561062157600080fd5b505af1158015610635573d6000803e3d6000fd5b505050508080610644906125c3565b915050610470565b50600180819055505050565b6060815167ffffffffffffffff81111561067557610674612699565b5b6040519080825280602002602001820160405280156106a35781602001602082028036833780820191505090505b50905060005b82518110156107e45760008382815181106106c7576106c661266a565b5b60200260200101519050600760008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008281526020019081526020016000205461072e43600454611778565b61073891906124ea565b61078982600660008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061174490919063ffffffff16565b610794576000610797565b60015b60ff166005546107a79190612490565b6107b19190612490565b8383815181106107c4576107c361266a565b5b6020026020010181815250505080806107dc906125c3565b9150506106a9565b5092915050565b600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b61081961104f565b15610859576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610850906122d3565b60405180910390fd5b600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156108ea576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108e190612293565b60405180910390fd5b6108f48282611066565b60005b82829050811015610a2a57600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b88d4fde33308686868181106109555761095461266a565b5b905060200201356040518463ffffffff1660e01b815260040161097a939291906121a8565b600060405180830381600087803b15801561099457600080fd5b505af11580156109a8573d6000803e3d6000fd5b50505050610a168383838181106109c2576109c161266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061179190919063ffffffff16565b508080610a22906125c3565b9150506108f7565b505050565b600063150b7a0260e01b905095945050505050565b6000600760008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600083815260200190815260200160002054610aa343600454611778565b11610ae3576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ada90612353565b60405180910390fd5b600760008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600083815260200190815260200160002054610b4043600454611778565b610b4a91906124ea565b610b9b83600660008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061174490919063ffffffff16565b610ba6576000610ba9565b60015b60ff16600554610bb99190612490565b610bc39190612490565b905092915050565b60055481565b60606000600660008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506000610c21826117ab565b67ffffffffffffffff811115610c3a57610c39612699565b5b604051908082528060200260200182016040528015610c685781602001602082028036833780820191505090505b50905060005b610c77836117ab565b811015610cc357610c9181846117c090919063ffffffff16565b828281518110610ca457610ca361266a565b5b6020026020010181815250508080610cbb906125c3565b915050610c6e565b508092505050919050565b610cd66117da565b73ffffffffffffffffffffffffffffffffffffffff16610cf461134d565b73ffffffffffffffffffffffffffffffffffffffff1614610d4a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d41906122f3565b60405180910390fd5b6000600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610da7919061218d565b60206040518083038186803b158015610dbf57600080fd5b505afa158015610dd3573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610df79190611f64565b9050600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33836040518363ffffffff1660e01b8152600401610e569291906121f2565b602060405180830381600087803b158015610e7057600080fd5b505af1158015610e84573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ea89190611f0a565b5050565b610eb46117da565b73ffffffffffffffffffffffffffffffffffffffff16610ed261134d565b73ffffffffffffffffffffffffffffffffffffffff1614610f28576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f1f906122f3565b60405180910390fd5b8060058190555050565b610f3a6117da565b73ffffffffffffffffffffffffffffffffffffffff16610f5861134d565b73ffffffffffffffffffffffffffffffffffffffff1614610fae576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fa5906122f3565b60405180910390fd5b610fb66117e2565b565b60045481565b610fc66117da565b73ffffffffffffffffffffffffffffffffffffffff16610fe461134d565b73ffffffffffffffffffffffffffffffffffffffff161461103a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611031906122f3565b60405180910390fd5b8043611046919061243a565b60048190555050565b6000600260009054906101000a900460ff16905090565b61106e61104f565b156110ae576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110a5906122d3565b60405180910390fd5b6000806110bd43600454611778565b905060005b8484905081101561117e576110f0338686848181106110e4576110e361266a565b5b90506020020135610a44565b836110fb919061243a565b925081600760003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008787858181106111525761115161266a565b5b905060200201358152602001908152602001600020819055508080611176906125c3565b9150506110c2565b50600082111561123957600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33846040518363ffffffff1660e01b81526004016111e59291906121f2565b602060405180830381600087803b1580156111ff57600080fd5b505af1158015611213573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112379190611f0a565b505b50505050565b6112476117da565b73ffffffffffffffffffffffffffffffffffffffff1661126561134d565b73ffffffffffffffffffffffffffffffffffffffff16146112bb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112b2906122f3565b60405180910390fd5b6112c56000611884565b565b6112cf6117da565b73ffffffffffffffffffffffffffffffffffffffff166112ed61134d565b73ffffffffffffffffffffffffffffffffffffffff1614611343576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161133a906122f3565b60405180910390fd5b61134b611948565b565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6007602052816000526040600020602052806000526040600020600091509150505481565b6113c961104f565b15611409576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611400906122d3565b60405180910390fd5b6002600154141561144f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161144690612333565b60405180910390fd5b60026001819055506114618282611066565b60005b82829050811015611640576114d98383838181106114855761148461266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061174490919063ffffffff16565b611518576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161150f90612313565b60405180910390fd5b61158283838381811061152e5761152d61266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061175e90919063ffffffff16565b50600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b88d4fde30338686868181106115d6576115d561266a565b5b905060200201356040518463ffffffff1660e01b81526004016115fb939291906121a8565b600060405180830381600087803b15801561161557600080fd5b505af1158015611629573d6000803e3d6000fd5b505050508080611638906125c3565b915050611464565b50600180819055505050565b6116546117da565b73ffffffffffffffffffffffffffffffffffffffff1661167261134d565b73ffffffffffffffffffffffffffffffffffffffff16146116c8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116bf906122f3565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611738576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161172f906122b3565b60405180910390fd5b61174181611884565b50565b6000611756836000018360001b6119eb565b905092915050565b6000611770836000018360001b611a0e565b905092915050565b60008183106117875781611789565b825b905092915050565b60006117a3836000018360001b611b22565b905092915050565b60006117b982600001611b92565b9050919050565b60006117cf8360000183611ba3565b60001c905092915050565b600033905090565b6117ea61104f565b611829576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161182090612273565b60405180910390fd5b6000600260006101000a81548160ff0219169083151502179055507f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa61186d6117da565b60405161187a919061218d565b60405180910390a1565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b61195061104f565b15611990576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611987906122d3565b60405180910390fd5b6001600260006101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586119d46117da565b6040516119e1919061218d565b60405180910390a1565b600080836001016000848152602001908152602001600020541415905092915050565b60008083600101600084815260200190815260200160002054905060008114611b16576000600182611a4091906124ea565b9050600060018660000180549050611a5891906124ea565b9050818114611ac7576000866000018281548110611a7957611a7861266a565b5b9060005260206000200154905080876000018481548110611a9d57611a9c61266a565b5b90600052602060002001819055508387600101600083815260200190815260200160002081905550505b85600001805480611adb57611ada61263b565b5b600190038181906000526020600020016000905590558560010160008681526020019081526020016000206000905560019350505050611b1c565b60009150505b92915050565b6000611b2e83836119eb565b611b87578260000182908060018154018082558091505060019003906000526020600020016000909190919091505582600001805490508360010160008481526020019081526020016000208190555060019050611b8c565b600090505b92915050565b600081600001805490509050919050565b6000826000018281548110611bbb57611bba61266a565b5b9060005260206000200154905092915050565b6000611be1611bdc846123b3565b61238e565b90508083825260208201905082856020860282011115611c0457611c036126d2565b5b60005b85811015611c345781611c1a8882611d42565b845260208401935060208301925050600181019050611c07565b5050509392505050565b600081359050611c4d81612863565b92915050565b60008083601f840112611c6957611c686126cd565b5b8235905067ffffffffffffffff811115611c8657611c856126c8565b5b602083019150836020820283011115611ca257611ca16126d2565b5b9250929050565b600082601f830112611cbe57611cbd6126cd565b5b8135611cce848260208601611bce565b91505092915050565b600081519050611ce68161287a565b92915050565b60008083601f840112611d0257611d016126cd565b5b8235905067ffffffffffffffff811115611d1f57611d1e6126c8565b5b602083019150836001820283011115611d3b57611d3a6126d2565b5b9250929050565b600081359050611d5181612891565b92915050565b600081519050611d6681612891565b92915050565b600060208284031215611d8257611d816126dc565b5b6000611d9084828501611c3e565b91505092915050565b600080600080600060808688031215611db557611db46126dc565b5b6000611dc388828901611c3e565b9550506020611dd488828901611c3e565b9450506040611de588828901611d42565b935050606086013567ffffffffffffffff811115611e0657611e056126d7565b5b611e1288828901611cec565b92509250509295509295909350565b60008060408385031215611e3857611e376126dc565b5b6000611e4685828601611c3e565b925050602083013567ffffffffffffffff811115611e6757611e666126d7565b5b611e7385828601611ca9565b9150509250929050565b60008060408385031215611e9457611e936126dc565b5b6000611ea285828601611c3e565b9250506020611eb385828601611d42565b9150509250929050565b60008060208385031215611ed457611ed36126dc565b5b600083013567ffffffffffffffff811115611ef257611ef16126d7565b5b611efe85828601611c53565b92509250509250929050565b600060208284031215611f2057611f1f6126dc565b5b6000611f2e84828501611cd7565b91505092915050565b600060208284031215611f4d57611f4c6126dc565b5b6000611f5b84828501611d42565b91505092915050565b600060208284031215611f7a57611f796126dc565b5b6000611f8884828501611d57565b91505092915050565b6000611f9d838361216f565b60208301905092915050565b611fb28161251e565b82525050565b6000611fc3826123ef565b611fcd8185612407565b9350611fd8836123df565b8060005b83811015612009578151611ff08882611f91565b9750611ffb836123fa565b925050600181019050611fdc565b5085935050505092915050565b61201f81612530565b82525050565b61202e8161253c565b82525050565b6000612041601483612429565b915061204c826126f2565b602082019050919050565b6000612064600f83612429565b915061206f8261271b565b602082019050919050565b6000612087602683612429565b915061209282612744565b604082019050919050565b60006120aa601083612429565b91506120b582612793565b602082019050919050565b60006120cd602083612429565b91506120d8826127bc565b602082019050919050565b60006120f0601883612429565b91506120fb826127e5565b602082019050919050565b6000612113600083612418565b915061211e8261280e565b600082019050919050565b6000612136601f83612429565b915061214182612811565b602082019050919050565b6000612159600e83612429565b91506121648261283a565b602082019050919050565b61217881612588565b82525050565b61218781612588565b82525050565b60006020820190506121a26000830184611fa9565b92915050565b60006080820190506121bd6000830186611fa9565b6121ca6020830185611fa9565b6121d7604083018461217e565b81810360608301526121e881612106565b9050949350505050565b60006040820190506122076000830185611fa9565b612214602083018461217e565b9392505050565b600060208201905081810360008301526122358184611fb8565b905092915050565b60006020820190506122526000830184612016565b92915050565b600060208201905061226d6000830184612025565b92915050565b6000602082019050818103600083015261228c81612034565b9050919050565b600060208201905081810360008301526122ac81612057565b9050919050565b600060208201905081810360008301526122cc8161207a565b9050919050565b600060208201905081810360008301526122ec8161209d565b9050919050565b6000602082019050818103600083015261230c816120c0565b9050919050565b6000602082019050818103600083015261232c816120e3565b9050919050565b6000602082019050818103600083015261234c81612129565b9050919050565b6000602082019050818103600083015261236c8161214c565b9050919050565b6000602082019050612388600083018461217e565b92915050565b60006123986123a9565b90506123a48282612592565b919050565b6000604051905090565b600067ffffffffffffffff8211156123ce576123cd612699565b5b602082029050602081019050919050565b6000819050602082019050919050565b600081519050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600061244582612588565b915061245083612588565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156124855761248461260c565b5b828201905092915050565b600061249b82612588565b91506124a683612588565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff04831182151516156124df576124de61260c565b5b828202905092915050565b60006124f582612588565b915061250083612588565b9250828210156125135761251261260c565b5b828203905092915050565b600061252982612568565b9050919050565b60008115159050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b61259b826126e1565b810181811067ffffffffffffffff821117156125ba576125b9612699565b5b80604052505050565b60006125ce82612588565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8214156126015761260061260c565b5b600182019050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f5061757361626c653a206e6f7420706175736564000000000000000000000000600082015250565b7f496e76616c696420616464726573730000000000000000000000000000000000600082015250565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f5061757361626c653a2070617573656400000000000000000000000000000000600082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b7f546861742042656172206973206e6f74207374616b65642e0000000000000000600082015250565b50565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b7f496e76616c696420626c6f636b73000000000000000000000000000000000000600082015250565b61286c8161251e565b811461287757600080fd5b50565b61288381612530565b811461288e57600080fd5b50565b61289a81612588565b81146128a557600080fd5b5056fea26469706673582212207841baaa5c094483c502bb6ae4d59e224bb21031ed4b73004bd146abf0ff29b564736f6c63430008070033000000000000000000000000838e240c0fcbd12fbffdb327d35a32dd2e73c7ea0000000000000000000000000000000000000000000000000005ebd3149ccb00000000000000000000000000000000000000000000000000000000000175f8a30000000000000000000000004f0c5042a11830feaba227840402e2409b0fc9dc

0x608060405234801561001057600080fd5b50600436106101425760003560e01c80634665096d116100b85780638456cb591161007c5780638456cb59146103295780638da5cb5b14610333578063b3d8d07914610351578063b44b71001461036f578063e449f3411461039f578063f2fde38b146103bb57610142565b80634665096d146102ab578063515a20ba146102c95780635c975abb146102e55780635eac623914610303578063715018a61461031f57610142565b80631852e8d91161010a5780631852e8d9146101fd5780632c4e722e1461022d57806333b69c4c1461024b57806334e361a11461027b57806334fcf437146102855780633f4ba83a146102a157610142565b8063021c1b4a14610147578063068c526f146101635780630c130269146101935780630fbf0a93146101b1578063150b7a02146101cd575b600080fd5b610161600480360381019061015c9190611ebd565b6103d7565b005b61017d60048036038101906101789190611e21565b610658565b60405161018a919061221b565b60405180910390f35b61019b6107eb565b6040516101a8919061218d565b60405180910390f35b6101cb60048036038101906101c69190611ebd565b610811565b005b6101e760048036038101906101e29190611d99565b610a2f565b6040516101f49190612258565b60405180910390f35b61021760048036038101906102129190611e7d565b610a44565b6040516102249190612373565b60405180910390f35b610235610bcb565b6040516102429190612373565b60405180910390f35b61026560048036038101906102609190611d6c565b610bd1565b604051610272919061221b565b60405180910390f35b610283610cce565b005b61029f600480360381019061029a9190611f37565b610eac565b005b6102a9610f32565b005b6102b3610fb8565b6040516102c09190612373565b60405180910390f35b6102e360048036038101906102de9190611f37565b610fbe565b005b6102ed61104f565b6040516102fa919061223d565b60405180910390f35b61031d60048036038101906103189190611ebd565b611066565b005b61032761123f565b005b6103316112c7565b005b61033b61134d565b604051610348919061218d565b60405180910390f35b610359611376565b604051610366919061218d565b60405180910390f35b61038960048036038101906103849190611e7d565b61139c565b6040516103969190612373565b60405180910390f35b6103b960048036038101906103b49190611ebd565b6113c1565b005b6103d560048036038101906103d09190611d6c565b61164c565b005b6103df61104f565b1561041f576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610416906122d3565b60405180910390fd5b60026001541415610465576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161045c90612333565b60405180910390fd5b600260018190555060005b8282905081101561064c576104e58383838181106104915761049061266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061174490919063ffffffff16565b610524576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161051b90612313565b60405180910390fd5b61058e83838381811061053a5761053961266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061175e90919063ffffffff16565b50600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b88d4fde30338686868181106105e2576105e161266a565b5b905060200201356040518463ffffffff1660e01b8152600401610607939291906121a8565b600060405180830381600087803b15801561062157600080fd5b505af1158015610635573d6000803e3d6000fd5b505050508080610644906125c3565b915050610470565b50600180819055505050565b6060815167ffffffffffffffff81111561067557610674612699565b5b6040519080825280602002602001820160405280156106a35781602001602082028036833780820191505090505b50905060005b82518110156107e45760008382815181106106c7576106c661266a565b5b60200260200101519050600760008673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008281526020019081526020016000205461072e43600454611778565b61073891906124ea565b61078982600660008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061174490919063ffffffff16565b610794576000610797565b60015b60ff166005546107a79190612490565b6107b19190612490565b8383815181106107c4576107c361266a565b5b6020026020010181815250505080806107dc906125c3565b9150506106a9565b5092915050565b600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b61081961104f565b15610859576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610850906122d3565b60405180910390fd5b600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614156108ea576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016108e190612293565b60405180910390fd5b6108f48282611066565b60005b82829050811015610a2a57600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b88d4fde33308686868181106109555761095461266a565b5b905060200201356040518463ffffffff1660e01b815260040161097a939291906121a8565b600060405180830381600087803b15801561099457600080fd5b505af11580156109a8573d6000803e3d6000fd5b50505050610a168383838181106109c2576109c161266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061179190919063ffffffff16565b508080610a22906125c3565b9150506108f7565b505050565b600063150b7a0260e01b905095945050505050565b6000600760008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600083815260200190815260200160002054610aa343600454611778565b11610ae3576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610ada90612353565b60405180910390fd5b600760008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600083815260200190815260200160002054610b4043600454611778565b610b4a91906124ea565b610b9b83600660008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061174490919063ffffffff16565b610ba6576000610ba9565b60015b60ff16600554610bb99190612490565b610bc39190612490565b905092915050565b60055481565b60606000600660008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002090506000610c21826117ab565b67ffffffffffffffff811115610c3a57610c39612699565b5b604051908082528060200260200182016040528015610c685781602001602082028036833780820191505090505b50905060005b610c77836117ab565b811015610cc357610c9181846117c090919063ffffffff16565b828281518110610ca457610ca361266a565b5b6020026020010181815250508080610cbb906125c3565b915050610c6e565b508092505050919050565b610cd66117da565b73ffffffffffffffffffffffffffffffffffffffff16610cf461134d565b73ffffffffffffffffffffffffffffffffffffffff1614610d4a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610d41906122f3565b60405180910390fd5b6000600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610da7919061218d565b60206040518083038186803b158015610dbf57600080fd5b505afa158015610dd3573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610df79190611f64565b9050600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33836040518363ffffffff1660e01b8152600401610e569291906121f2565b602060405180830381600087803b158015610e7057600080fd5b505af1158015610e84573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610ea89190611f0a565b5050565b610eb46117da565b73ffffffffffffffffffffffffffffffffffffffff16610ed261134d565b73ffffffffffffffffffffffffffffffffffffffff1614610f28576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610f1f906122f3565b60405180910390fd5b8060058190555050565b610f3a6117da565b73ffffffffffffffffffffffffffffffffffffffff16610f5861134d565b73ffffffffffffffffffffffffffffffffffffffff1614610fae576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610fa5906122f3565b60405180910390fd5b610fb66117e2565b565b60045481565b610fc66117da565b73ffffffffffffffffffffffffffffffffffffffff16610fe461134d565b73ffffffffffffffffffffffffffffffffffffffff161461103a576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611031906122f3565b60405180910390fd5b8043611046919061243a565b60048190555050565b6000600260009054906101000a900460ff16905090565b61106e61104f565b156110ae576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016110a5906122d3565b60405180910390fd5b6000806110bd43600454611778565b905060005b8484905081101561117e576110f0338686848181106110e4576110e361266a565b5b90506020020135610a44565b836110fb919061243a565b925081600760003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008787858181106111525761115161266a565b5b905060200201358152602001908152602001600020819055508080611176906125c3565b9150506110c2565b50600082111561123957600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663a9059cbb33846040518363ffffffff1660e01b81526004016111e59291906121f2565b602060405180830381600087803b1580156111ff57600080fd5b505af1158015611213573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052508101906112379190611f0a565b505b50505050565b6112476117da565b73ffffffffffffffffffffffffffffffffffffffff1661126561134d565b73ffffffffffffffffffffffffffffffffffffffff16146112bb576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112b2906122f3565b60405180910390fd5b6112c56000611884565b565b6112cf6117da565b73ffffffffffffffffffffffffffffffffffffffff166112ed61134d565b73ffffffffffffffffffffffffffffffffffffffff1614611343576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161133a906122f3565b60405180910390fd5b61134b611948565b565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff16905090565b600360009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6007602052816000526040600020602052806000526040600020600091509150505481565b6113c961104f565b15611409576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611400906122d3565b60405180910390fd5b6002600154141561144f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161144690612333565b60405180910390fd5b60026001819055506114618282611066565b60005b82829050811015611640576114d98383838181106114855761148461266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061174490919063ffffffff16565b611518576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161150f90612313565b60405180910390fd5b61158283838381811061152e5761152d61266a565b5b90506020020135600660003373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002061175e90919063ffffffff16565b50600260019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1663b88d4fde30338686868181106115d6576115d561266a565b5b905060200201356040518463ffffffff1660e01b81526004016115fb939291906121a8565b600060405180830381600087803b15801561161557600080fd5b505af1158015611629573d6000803e3d6000fd5b505050508080611638906125c3565b915050611464565b50600180819055505050565b6116546117da565b73ffffffffffffffffffffffffffffffffffffffff1661167261134d565b73ffffffffffffffffffffffffffffffffffffffff16146116c8576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016116bf906122f3565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff161415611738576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161172f906122b3565b60405180910390fd5b61174181611884565b50565b6000611756836000018360001b6119eb565b905092915050565b6000611770836000018360001b611a0e565b905092915050565b60008183106117875781611789565b825b905092915050565b60006117a3836000018360001b611b22565b905092915050565b60006117b982600001611b92565b9050919050565b60006117cf8360000183611ba3565b60001c905092915050565b600033905090565b6117ea61104f565b611829576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161182090612273565b60405180910390fd5b6000600260006101000a81548160ff0219169083151502179055507f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa61186d6117da565b60405161187a919061218d565b60405180910390a1565b60008060009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050816000806101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff1602179055508173ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e060405160405180910390a35050565b61195061104f565b15611990576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611987906122d3565b60405180910390fd5b6001600260006101000a81548160ff0219169083151502179055507f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586119d46117da565b6040516119e1919061218d565b60405180910390a1565b600080836001016000848152602001908152602001600020541415905092915050565b60008083600101600084815260200190815260200160002054905060008114611b16576000600182611a4091906124ea565b9050600060018660000180549050611a5891906124ea565b9050818114611ac7576000866000018281548110611a7957611a7861266a565b5b9060005260206000200154905080876000018481548110611a9d57611a9c61266a565b5b90600052602060002001819055508387600101600083815260200190815260200160002081905550505b85600001805480611adb57611ada61263b565b5b600190038181906000526020600020016000905590558560010160008681526020019081526020016000206000905560019350505050611b1c565b60009150505b92915050565b6000611b2e83836119eb565b611b87578260000182908060018154018082558091505060019003906000526020600020016000909190919091505582600001805490508360010160008481526020019081526020016000208190555060019050611b8c565b600090505b92915050565b600081600001805490509050919050565b6000826000018281548110611bbb57611bba61266a565b5b9060005260206000200154905092915050565b6000611be1611bdc846123b3565b61238e565b90508083825260208201905082856020860282011115611c0457611c036126d2565b5b60005b85811015611c345781611c1a8882611d42565b845260208401935060208301925050600181019050611c07565b5050509392505050565b600081359050611c4d81612863565b92915050565b60008083601f840112611c6957611c686126cd565b5b8235905067ffffffffffffffff811115611c8657611c856126c8565b5b602083019150836020820283011115611ca257611ca16126d2565b5b9250929050565b600082601f830112611cbe57611cbd6126cd565b5b8135611cce848260208601611bce565b91505092915050565b600081519050611ce68161287a565b92915050565b60008083601f840112611d0257611d016126cd565b5b8235905067ffffffffffffffff811115611d1f57611d1e6126c8565b5b602083019150836001820283011115611d3b57611d3a6126d2565b5b9250929050565b600081359050611d5181612891565b92915050565b600081519050611d6681612891565b92915050565b600060208284031215611d8257611d816126dc565b5b6000611d9084828501611c3e565b91505092915050565b600080600080600060808688031215611db557611db46126dc565b5b6000611dc388828901611c3e565b9550506020611dd488828901611c3e565b9450506040611de588828901611d42565b935050606086013567ffffffffffffffff811115611e0657611e056126d7565b5b611e1288828901611cec565b92509250509295509295909350565b60008060408385031215611e3857611e376126dc565b5b6000611e4685828601611c3e565b925050602083013567ffffffffffffffff811115611e6757611e666126d7565b5b611e7385828601611ca9565b9150509250929050565b60008060408385031215611e9457611e936126dc565b5b6000611ea285828601611c3e565b9250506020611eb385828601611d42565b9150509250929050565b60008060208385031215611ed457611ed36126dc565b5b600083013567ffffffffffffffff811115611ef257611ef16126d7565b5b611efe85828601611c53565b92509250509250929050565b600060208284031215611f2057611f1f6126dc565b5b6000611f2e84828501611cd7565b91505092915050565b600060208284031215611f4d57611f4c6126dc565b5b6000611f5b84828501611d42565b91505092915050565b600060208284031215611f7a57611f796126dc565b5b6000611f8884828501611d57565b91505092915050565b6000611f9d838361216f565b60208301905092915050565b611fb28161251e565b82525050565b6000611fc3826123ef565b611fcd8185612407565b9350611fd8836123df565b8060005b83811015612009578151611ff08882611f91565b9750611ffb836123fa565b925050600181019050611fdc565b5085935050505092915050565b61201f81612530565b82525050565b61202e8161253c565b82525050565b6000612041601483612429565b915061204c826126f2565b602082019050919050565b6000612064600f83612429565b915061206f8261271b565b602082019050919050565b6000612087602683612429565b915061209282612744565b604082019050919050565b60006120aa601083612429565b91506120b582612793565b602082019050919050565b60006120cd602083612429565b91506120d8826127bc565b602082019050919050565b60006120f0601883612429565b91506120fb826127e5565b602082019050919050565b6000612113600083612418565b915061211e8261280e565b600082019050919050565b6000612136601f83612429565b915061214182612811565b602082019050919050565b6000612159600e83612429565b91506121648261283a565b602082019050919050565b61217881612588565b82525050565b61218781612588565b82525050565b60006020820190506121a26000830184611fa9565b92915050565b60006080820190506121bd6000830186611fa9565b6121ca6020830185611fa9565b6121d7604083018461217e565b81810360608301526121e881612106565b9050949350505050565b60006040820190506122076000830185611fa9565b612214602083018461217e565b9392505050565b600060208201905081810360008301526122358184611fb8565b905092915050565b60006020820190506122526000830184612016565b92915050565b600060208201905061226d6000830184612025565b92915050565b6000602082019050818103600083015261228c81612034565b9050919050565b600060208201905081810360008301526122ac81612057565b9050919050565b600060208201905081810360008301526122cc8161207a565b9050919050565b600060208201905081810360008301526122ec8161209d565b9050919050565b6000602082019050818103600083015261230c816120c0565b9050919050565b6000602082019050818103600083015261232c816120e3565b9050919050565b6000602082019050818103600083015261234c81612129565b9050919050565b6000602082019050818103600083015261236c8161214c565b9050919050565b6000602082019050612388600083018461217e565b92915050565b60006123986123a9565b90506123a48282612592565b919050565b6000604051905090565b600067ffffffffffffffff8211156123ce576123cd612699565b5b602082029050602081019050919050565b6000819050602082019050919050565b600081519050919050565b6000602082019050919050565b600082825260208201905092915050565b600082825260208201905092915050565b600082825260208201905092915050565b600061244582612588565b915061245083612588565b9250827fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff038211156124855761248461260c565b5b828201905092915050565b600061249b82612588565b91506124a683612588565b9250817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff04831182151516156124df576124de61260c565b5b828202905092915050565b60006124f582612588565b915061250083612588565b9250828210156125135761251261260c565b5b828203905092915050565b600061252982612568565b9050919050565b60008115159050919050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b6000819050919050565b61259b826126e1565b810181811067ffffffffffffffff821117156125ba576125b9612699565b5b80604052505050565b60006125ce82612588565b91507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff8214156126015761260061260c565b5b600182019050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600080fd5b600080fd5b600080fd5b600080fd5b600080fd5b6000601f19601f8301169050919050565b7f5061757361626c653a206e6f7420706175736564000000000000000000000000600082015250565b7f496e76616c696420616464726573730000000000000000000000000000000000600082015250565b7f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160008201527f6464726573730000000000000000000000000000000000000000000000000000602082015250565b7f5061757361626c653a2070617573656400000000000000000000000000000000600082015250565b7f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572600082015250565b7f546861742042656172206973206e6f74207374616b65642e0000000000000000600082015250565b50565b7f5265656e7472616e637947756172643a207265656e7472616e742063616c6c00600082015250565b7f496e76616c696420626c6f636b73000000000000000000000000000000000000600082015250565b61286c8161251e565b811461287757600080fd5b50565b61288381612530565b811461288e57600080fd5b50565b61289a81612588565b81146128a557600080fd5b5056fea26469706673582212207841baaa5c094483c502bb6ae4d59e224bb21031ed4b73004bd146abf0ff29b564736f6c63430008070033

000000000000000000000000838e240c0fcbd12fbffdb327d35a32dd2e73c7ea0000000000000000000000000000000000000000000000000005ebd3149ccb00000000000000000000000000000000000000000000000000000000000175f8a30000000000000000000000004f0c5042a11830feaba227840402e2409b0fc9dc

-----Decoded View---------------
Arg [0] : _bearsAddress (address): 0x838E240c0FcBd12fBfFdB327d35A32DD2E73C7ea
Arg [1] : _rate (uint256): 1666666700000000
Arg [2] : _expiration (uint256): 24508579
Arg [3] : _honeyAddress (address): 0x4F0c5042A11830fEaBA227840402e2409b0FC9dC

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 000000000000000000000000838e240c0fcbd12fbffdb327d35a32dd2e73c7ea
Arg [1] : 0000000000000000000000000000000000000000000000000005ebd3149ccb00
Arg [2] : 000000000000000000000000000000000000000000000000000000000175f8a3
Arg [3] : 0000000000000000000000004f0c5042a11830feaba227840402e2409b0fc9dc

40256:5638:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44858:551;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42195:530;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40440:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43716:472;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45672:219;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42793:401;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40648:19;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41749:372;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;45469:195;;;:::i;:::-;;41444:80;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;41257:65;;;:::i;:::-;;40581:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;41577:119;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;36454:86;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43244:444;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39353:103;;;:::i;:::-;;41161:61;;;:::i;:::-;;38702:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40509:27;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40743:67;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44234:571;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39611:201;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44858:551;36780:8;:6;:8::i;:::-;36779:9;36771:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;5988:1:::1;6586:7;;:19;;6578:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;5988:1;6719:7;:18;;;;44973:9:::2;44968:434;44988:8;;:15;;44984:1;:19;44968:434;;;45051:41;45080:8;;45089:1;45080:11;;;;;;;:::i;:::-;;;;;;;;45051:7;:19;45059:10;45051:19;;;;;;;;;;;;;;;:28;;:41;;;;:::i;:::-;45025:127;;;;;;;;;;;;:::i;:::-;;;;;;;;;45169:39;45196:8;;45205:1;45196:11;;;;;;;:::i;:::-;;;;;;;;45169:7;:19;45177:10;45169:19;;;;;;;;;;;;;;;:26;;:39;;;;:::i;:::-;;45233:12;;;;;;;;;;;45225:38;;;45290:4;45314:10;45343:8;;45352:1;45343:11;;;;;;;:::i;:::-;;;;;;;;45225:165;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;45005:3;;;;;:::i;:::-;;;;44968:434;;;;5944:1:::1;6898:7:::0;:22:::1;;;;44858:551:::0;;:::o;42195:530::-;42310:24;42375:8;:15;42361:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42351:40;;42407:9;42402:291;42422:8;:15;42418:1;:19;42402:291;;;42455:15;42473:8;42482:1;42473:11;;;;;;;;:::i;:::-;;;;;;;;42455:29;;42652:12;:21;42665:7;42652:21;;;;;;;;;;;;;;;:30;42674:7;42652:30;;;;;;;;;;;;42601:34;42610:12;42624:10;;42601:8;:34::i;:::-;:81;;;;:::i;:::-;42542:34;42568:7;42542;:16;42550:7;42542:16;;;;;;;;;;;;;;;:25;;:34;;;;:::i;:::-;:42;;42583:1;42542:42;;;42579:1;42542:42;42522:63;;:4;;:63;;;;:::i;:::-;:161;;;;:::i;:::-;42497:7;42505:1;42497:10;;;;;;;;:::i;:::-;;;;;;;:186;;;;;42444:249;42439:3;;;;;:::i;:::-;;;;42402:291;;;;42195:530;;;;:::o;40440:27::-;;;;;;;;;;;;;:::o;43716:472::-;36780:8;:6;:8::i;:::-;36779:9;36771:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;43816:12:::1;;;;;;;;;;;43802:26;;:10;:26;;;;43794:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;43859:22;43872:8;;43859:12;:22::i;:::-;43899:9;43894:287;43914:8;;:15;;43910:1;:19;43894:287;;;43959:12;;;;;;;;;;;43951:38;;;44008:10;44045:4;44069:8;;44078:1;44069:11;;;;;;;:::i;:::-;;;;;;;;43951:165;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;44133:36;44157:8;;44166:1;44157:11;;;;;;;:::i;:::-;;;;;;;;44133:7;:19;44141:10;44133:19;;;;;;;;;;;;;;;:23;;:36;;;;:::i;:::-;;43931:3;;;;;:::i;:::-;;;;43894:287;;;;43716:472:::0;;:::o;45672:219::-;45816:6;45842:41;;;45835:48;;45672:219;;;;;;;:::o;42793:401::-;42897:7;42960:12;:21;42973:7;42960:21;;;;;;;;;;;;;;;:30;42982:7;42960:30;;;;;;;;;;;;42923:34;42932:12;42946:10;;42923:8;:34::i;:::-;:67;42915:94;;;;;;;;;;;;:::i;:::-;;;;;;;;;43155:12;:21;43168:7;43155:21;;;;;;;;;;;;;;;:30;43177:7;43155:30;;;;;;;;;;;;43104:34;43113:12;43127:10;;43104:8;:34::i;:::-;:81;;;;:::i;:::-;43045:34;43071:7;43045;:16;43053:7;43045:16;;;;;;;;;;;;;;;:25;;:34;;;;:::i;:::-;:42;;43086:1;43045:42;;;43082:1;43045:42;43025:63;;:4;;:63;;;;:::i;:::-;:161;;;;:::i;:::-;43018:168;;42793:401;;;;:::o;40648:19::-;;;;:::o;41749:372::-;41830:16;41857:38;41898:7;:16;41906:7;41898:16;;;;;;;;;;;;;;;41857:57;;41923:25;41966:17;:8;:15;:17::i;:::-;41951:33;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41923:61;;42000:9;41995:93;42015:17;:8;:15;:17::i;:::-;42011:1;:21;41995:93;;;42064:14;42076:1;42064:8;:11;;:14;;;;:::i;:::-;42050:8;42059:1;42050:11;;;;;;;;:::i;:::-;;;;;;;:28;;;;;42034:3;;;;;:::i;:::-;;;;41995:93;;;;42105:8;42098:15;;;;41749:372;;;:::o;45469:195::-;38933:12;:10;:12::i;:::-;38922:23;;:7;:5;:7::i;:::-;:23;;;38914:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;45524:19:::1;45553:12;;;;;;;;;;;45546:30;;;45585:4;45546:45;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45524:67;;45609:12;;;;;;;;;;;45602:29;;;45632:10;45644:11;45602:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;45513:151;45469:195::o:0;41444:80::-;38933:12;:10;:12::i;:::-;38922:23;;:7;:5;:7::i;:::-;:23;;;38914:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;41511:5:::1;41504:4;:12;;;;41444:80:::0;:::o;41257:65::-;38933:12;:10;:12::i;:::-;38922:23;;:7;:5;:7::i;:::-;:23;;;38914:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;41304:10:::1;:8;:10::i;:::-;41257:65::o:0;40581:25::-;;;;:::o;41577:119::-;38933:12;:10;:12::i;:::-;38922:23;;:7;:5;:7::i;:::-;:23;;;38914:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;41677:11:::1;41662:12;:26;;;;:::i;:::-;41649:10;:39;;;;41577:119:::0;:::o;36454:86::-;36501:4;36525:7;;;;;;;;;;;36518:14;;36454:86;:::o;43244:444::-;36780:8;:6;:8::i;:::-;36779:9;36771:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;43325:14:::1;43349:16:::0;43368:34:::1;43377:12;43391:10;;43368:8;:34::i;:::-;43349:53;;43418:9;43413:172;43433:8;;:15;;43429:1;:19;43413:172;;;43476:40;43492:10;43504:8;;43513:1;43504:11;;;;;;;:::i;:::-;;;;;;;;43476:15;:40::i;:::-;43466:50;;;;;:::i;:::-;;;43567:8;43527:12;:24;43540:10;43527:24;;;;;;;;;;;;;;;:37;43552:8;;43561:1;43552:11;;;;;;;:::i;:::-;;;;;;;;43527:37;;;;;;;;;;;:48;;;;43450:3;;;;;:::i;:::-;;;;43413:172;;;;43608:1;43599:6;:10;43595:86;;;43629:12;;;;;;;;;;;43622:29;;;43652:10;43664:6;43622:49;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;43595:86;43316:372;;43244:444:::0;;:::o;39353:103::-;38933:12;:10;:12::i;:::-;38922:23;;:7;:5;:7::i;:::-;:23;;;38914:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;39418:30:::1;39445:1;39418:18;:30::i;:::-;39353:103::o:0;41161:61::-;38933:12;:10;:12::i;:::-;38922:23;;:7;:5;:7::i;:::-;:23;;;38914:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;41206:8:::1;:6;:8::i;:::-;41161:61::o:0;38702:87::-;38748:7;38775:6;;;;;;;;;;;38768:13;;38702:87;:::o;40509:27::-;;;;;;;;;;;;;:::o;40743:67::-;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;44234:571::-;36780:8;:6;:8::i;:::-;36779:9;36771:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;5988:1:::1;6586:7;;:19;;6578:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;5988:1;6719:7;:18;;;;44329:22:::2;44342:8;;44329:12;:22::i;:::-;44369:9;44364:434;44384:8;;:15;;44380:1;:19;44364:434;;;44447:41;44476:8;;44485:1;44476:11;;;;;;;:::i;:::-;;;;;;;;44447:7;:19;44455:10;44447:19;;;;;;;;;;;;;;;:28;;:41;;;;:::i;:::-;44421:127;;;;;;;;;;;;:::i;:::-;;;;;;;;;44565:39;44592:8;;44601:1;44592:11;;;;;;;:::i;:::-;;;;;;;;44565:7;:19;44573:10;44565:19;;;;;;;;;;;;;;;:26;;:39;;;;:::i;:::-;;44629:12;;;;;;;;;;;44621:38;;;44686:4;44710:10;44739:8;;44748:1;44739:11;;;;;;;:::i;:::-;;;;;;;;44621:165;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;44401:3;;;;;:::i;:::-;;;;44364:434;;;;5944:1:::1;6898:7:::0;:22:::1;;;;44234:571:::0;;:::o;39611:201::-;38933:12;:10;:12::i;:::-;38922:23;;:7;:5;:7::i;:::-;:23;;;38914:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;39720:1:::1;39700:22;;:8;:22;;;;39692:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;39776:28;39795:8;39776:18;:28::i;:::-;39611:201:::0;:::o;17855:146::-;17932:4;17956:37;17966:3;:10;;17986:5;17978:14;;17956:9;:37::i;:::-;17949:44;;17855:146;;;;:::o;17632:137::-;17702:4;17726:35;17734:3;:10;;17754:5;17746:14;;17726:7;:35::i;:::-;17719:42;;17632:137;;;;:::o;3384:106::-;3442:7;3473:1;3469;:5;:13;;3481:1;3469:13;;;3477:1;3469:13;3462:20;;3384:106;;;;:::o;17325:131::-;17392:4;17416:32;17421:3;:10;;17441:5;17433:14;;17416:4;:32::i;:::-;17409:39;;17325:131;;;;:::o;18087:114::-;18147:7;18174:19;18182:3;:10;;18174:7;:19::i;:::-;18167:26;;18087:114;;;:::o;18555:137::-;18626:7;18661:22;18665:3;:10;;18677:5;18661:3;:22::i;:::-;18653:31;;18646:38;;18555:137;;;;:::o;35108:98::-;35161:7;35188:10;35181:17;;35108:98;:::o;37513:120::-;37057:8;:6;:8::i;:::-;37049:41;;;;;;;;;;;;:::i;:::-;;;;;;;;;37582:5:::1;37572:7;;:15;;;;;;;;;;;;;;;;;;37603:22;37612:12;:10;:12::i;:::-;37603:22;;;;;;:::i;:::-;;;;;;;;37513:120::o:0;39972:191::-;40046:16;40065:6;;;;;;;;;;;40046:25;;40091:8;40082:6;;:17;;;;;;;;;;;;;;;;;;40146:8;40115:40;;40136:8;40115:40;;;;;;;;;;;;40035:128;39972:191;:::o;37254:118::-;36780:8;:6;:8::i;:::-;36779:9;36771:38;;;;;;;;;;;;:::i;:::-;;;;;;;;;37324:4:::1;37314:7;;:14;;;;;;;;;;;;;;;;;;37344:20;37351:12;:10;:12::i;:::-;37344:20;;;;;;:::i;:::-;;;;;;;;37254:118::o:0;10818:129::-;10891:4;10938:1;10915:3;:12;;:19;10928:5;10915:19;;;;;;;;;;;;:24;;10908:31;;10818:129;;;;:::o;9312:1420::-;9378:4;9496:18;9517:3;:12;;:19;9530:5;9517:19;;;;;;;;;;;;9496:40;;9567:1;9553:10;:15;9549:1176;;9928:21;9965:1;9952:10;:14;;;;:::i;:::-;9928:38;;9981:17;10022:1;10001:3;:11;;:18;;;;:22;;;;:::i;:::-;9981:42;;10057:13;10044:9;:26;10040:405;;10091:17;10111:3;:11;;10123:9;10111:22;;;;;;;;:::i;:::-;;;;;;;;;;10091:42;;10265:9;10236:3;:11;;10248:13;10236:26;;;;;;;;:::i;:::-;;;;;;;;;:38;;;;10376:10;10350:3;:12;;:23;10363:9;10350:23;;;;;;;;;;;:36;;;;10072:373;10040:405;10526:3;:11;;:17;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;10621:3;:12;;:19;10634:5;10621:19;;;;;;;;;;;10614:26;;;10664:4;10657:11;;;;;;;9549:1176;10708:5;10701:12;;;9312:1420;;;;;:::o;8722:414::-;8785:4;8807:21;8817:3;8822:5;8807:9;:21::i;:::-;8802:327;;8845:3;:11;;8862:5;8845:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9028:3;:11;;:18;;;;9006:3;:12;;:19;9019:5;9006:19;;;;;;;;;;;:40;;;;9068:4;9061:11;;;;8802:327;9112:5;9105:12;;8722:414;;;;;:::o;11033:109::-;11089:7;11116:3;:11;;:18;;;;11109:25;;11033:109;;;:::o;11496:120::-;11563:7;11590:3;:11;;11602:5;11590:18;;;;;;;;:::i;:::-;;;;;;;;;;11583:25;;11496:120;;;;:::o;24:722:1:-;120:5;145:81;161:64;218:6;161:64;:::i;:::-;145:81;:::i;:::-;136:90;;246:5;275:6;268:5;261:21;309:4;302:5;298:16;291:23;;335:6;385:3;377:4;369:6;365:17;360:3;356:27;353:36;350:143;;;404:79;;:::i;:::-;350:143;517:1;502:238;527:6;524:1;521:13;502:238;;;595:3;624:37;657:3;645:10;624:37;:::i;:::-;619:3;612:50;691:4;686:3;682:14;675:21;;725:4;720:3;716:14;709:21;;562:178;549:1;546;542:9;537:14;;502:238;;;506:14;126:620;;24:722;;;;;:::o;752:139::-;798:5;836:6;823:20;814:29;;852:33;879:5;852:33;:::i;:::-;752:139;;;;:::o;914:568::-;987:8;997:6;1047:3;1040:4;1032:6;1028:17;1024:27;1014:122;;1055:79;;:::i;:::-;1014:122;1168:6;1155:20;1145:30;;1198:18;1190:6;1187:30;1184:117;;;1220:79;;:::i;:::-;1184:117;1334:4;1326:6;1322:17;1310:29;;1388:3;1380:4;1372:6;1368:17;1358:8;1354:32;1351:41;1348:128;;;1395:79;;:::i;:::-;1348:128;914:568;;;;;:::o;1505:370::-;1576:5;1625:3;1618:4;1610:6;1606:17;1602:27;1592:122;;1633:79;;:::i;:::-;1592:122;1750:6;1737:20;1775:94;1865:3;1857:6;1850:4;1842:6;1838:17;1775:94;:::i;:::-;1766:103;;1582:293;1505:370;;;;:::o;1881:137::-;1935:5;1966:6;1960:13;1951:22;;1982:30;2006:5;1982:30;:::i;:::-;1881:137;;;;:::o;2037:552::-;2094:8;2104:6;2154:3;2147:4;2139:6;2135:17;2131:27;2121:122;;2162:79;;:::i;:::-;2121:122;2275:6;2262:20;2252:30;;2305:18;2297:6;2294:30;2291:117;;;2327:79;;:::i;:::-;2291:117;2441:4;2433:6;2429:17;2417:29;;2495:3;2487:4;2479:6;2475:17;2465:8;2461:32;2458:41;2455:128;;;2502:79;;:::i;:::-;2455:128;2037:552;;;;;:::o;2595:139::-;2641:5;2679:6;2666:20;2657:29;;2695:33;2722:5;2695:33;:::i;:::-;2595:139;;;;:::o;2740:143::-;2797:5;2828:6;2822:13;2813:22;;2844:33;2871:5;2844:33;:::i;:::-;2740:143;;;;:::o;2889:329::-;2948:6;2997:2;2985:9;2976:7;2972:23;2968:32;2965:119;;;3003:79;;:::i;:::-;2965:119;3123:1;3148:53;3193:7;3184:6;3173:9;3169:22;3148:53;:::i;:::-;3138:63;;3094:117;2889:329;;;;:::o;3224:963::-;3321:6;3329;3337;3345;3353;3402:3;3390:9;3381:7;3377:23;3373:33;3370:120;;;3409:79;;:::i;:::-;3370:120;3529:1;3554:53;3599:7;3590:6;3579:9;3575:22;3554:53;:::i;:::-;3544:63;;3500:117;3656:2;3682:53;3727:7;3718:6;3707:9;3703:22;3682:53;:::i;:::-;3672:63;;3627:118;3784:2;3810:53;3855:7;3846:6;3835:9;3831:22;3810:53;:::i;:::-;3800:63;;3755:118;3940:2;3929:9;3925:18;3912:32;3971:18;3963:6;3960:30;3957:117;;;3993:79;;:::i;:::-;3957:117;4106:64;4162:7;4153:6;4142:9;4138:22;4106:64;:::i;:::-;4088:82;;;;3883:297;3224:963;;;;;;;;:::o;4193:684::-;4286:6;4294;4343:2;4331:9;4322:7;4318:23;4314:32;4311:119;;;4349:79;;:::i;:::-;4311:119;4469:1;4494:53;4539:7;4530:6;4519:9;4515:22;4494:53;:::i;:::-;4484:63;;4440:117;4624:2;4613:9;4609:18;4596:32;4655:18;4647:6;4644:30;4641:117;;;4677:79;;:::i;:::-;4641:117;4782:78;4852:7;4843:6;4832:9;4828:22;4782:78;:::i;:::-;4772:88;;4567:303;4193:684;;;;;:::o;4883:474::-;4951:6;4959;5008:2;4996:9;4987:7;4983:23;4979:32;4976:119;;;5014:79;;:::i;:::-;4976:119;5134:1;5159:53;5204:7;5195:6;5184:9;5180:22;5159:53;:::i;:::-;5149:63;;5105:117;5261:2;5287:53;5332:7;5323:6;5312:9;5308:22;5287:53;:::i;:::-;5277:63;;5232:118;4883:474;;;;;:::o;5363:559::-;5449:6;5457;5506:2;5494:9;5485:7;5481:23;5477:32;5474:119;;;5512:79;;:::i;:::-;5474:119;5660:1;5649:9;5645:17;5632:31;5690:18;5682:6;5679:30;5676:117;;;5712:79;;:::i;:::-;5676:117;5825:80;5897:7;5888:6;5877:9;5873:22;5825:80;:::i;:::-;5807:98;;;;5603:312;5363:559;;;;;:::o;5928:345::-;5995:6;6044:2;6032:9;6023:7;6019:23;6015:32;6012:119;;;6050:79;;:::i;:::-;6012:119;6170:1;6195:61;6248:7;6239:6;6228:9;6224:22;6195:61;:::i;:::-;6185:71;;6141:125;5928:345;;;;:::o;6279:329::-;6338:6;6387:2;6375:9;6366:7;6362:23;6358:32;6355:119;;;6393:79;;:::i;:::-;6355:119;6513:1;6538:53;6583:7;6574:6;6563:9;6559:22;6538:53;:::i;:::-;6528:63;;6484:117;6279:329;;;;:::o;6614:351::-;6684:6;6733:2;6721:9;6712:7;6708:23;6704:32;6701:119;;;6739:79;;:::i;:::-;6701:119;6859:1;6884:64;6940:7;6931:6;6920:9;6916:22;6884:64;:::i;:::-;6874:74;;6830:128;6614:351;;;;:::o;6971:179::-;7040:10;7061:46;7103:3;7095:6;7061:46;:::i;:::-;7139:4;7134:3;7130:14;7116:28;;6971:179;;;;:::o;7156:118::-;7243:24;7261:5;7243:24;:::i;:::-;7238:3;7231:37;7156:118;;:::o;7310:732::-;7429:3;7458:54;7506:5;7458:54;:::i;:::-;7528:86;7607:6;7602:3;7528:86;:::i;:::-;7521:93;;7638:56;7688:5;7638:56;:::i;:::-;7717:7;7748:1;7733:284;7758:6;7755:1;7752:13;7733:284;;;7834:6;7828:13;7861:63;7920:3;7905:13;7861:63;:::i;:::-;7854:70;;7947:60;8000:6;7947:60;:::i;:::-;7937:70;;7793:224;7780:1;7777;7773:9;7768:14;;7733:284;;;7737:14;8033:3;8026:10;;7434:608;;;7310:732;;;;:::o;8048:109::-;8129:21;8144:5;8129:21;:::i;:::-;8124:3;8117:34;8048:109;;:::o;8163:115::-;8248:23;8265:5;8248:23;:::i;:::-;8243:3;8236:36;8163:115;;:::o;8284:366::-;8426:3;8447:67;8511:2;8506:3;8447:67;:::i;:::-;8440:74;;8523:93;8612:3;8523:93;:::i;:::-;8641:2;8636:3;8632:12;8625:19;;8284:366;;;:::o;8656:::-;8798:3;8819:67;8883:2;8878:3;8819:67;:::i;:::-;8812:74;;8895:93;8984:3;8895:93;:::i;:::-;9013:2;9008:3;9004:12;8997:19;;8656:366;;;:::o;9028:::-;9170:3;9191:67;9255:2;9250:3;9191:67;:::i;:::-;9184:74;;9267:93;9356:3;9267:93;:::i;:::-;9385:2;9380:3;9376:12;9369:19;;9028:366;;;:::o;9400:::-;9542:3;9563:67;9627:2;9622:3;9563:67;:::i;:::-;9556:74;;9639:93;9728:3;9639:93;:::i;:::-;9757:2;9752:3;9748:12;9741:19;;9400:366;;;:::o;9772:::-;9914:3;9935:67;9999:2;9994:3;9935:67;:::i;:::-;9928:74;;10011:93;10100:3;10011:93;:::i;:::-;10129:2;10124:3;10120:12;10113:19;;9772:366;;;:::o;10144:::-;10286:3;10307:67;10371:2;10366:3;10307:67;:::i;:::-;10300:74;;10383:93;10472:3;10383:93;:::i;:::-;10501:2;10496:3;10492:12;10485:19;;10144:366;;;:::o;10516:362::-;10657:3;10678:65;10741:1;10736:3;10678:65;:::i;:::-;10671:72;;10752:93;10841:3;10752:93;:::i;:::-;10870:1;10865:3;10861:11;10854:18;;10516:362;;;:::o;10884:366::-;11026:3;11047:67;11111:2;11106:3;11047:67;:::i;:::-;11040:74;;11123:93;11212:3;11123:93;:::i;:::-;11241:2;11236:3;11232:12;11225:19;;10884:366;;;:::o;11256:::-;11398:3;11419:67;11483:2;11478:3;11419:67;:::i;:::-;11412:74;;11495:93;11584:3;11495:93;:::i;:::-;11613:2;11608:3;11604:12;11597:19;;11256:366;;;:::o;11628:108::-;11705:24;11723:5;11705:24;:::i;:::-;11700:3;11693:37;11628:108;;:::o;11742:118::-;11829:24;11847:5;11829:24;:::i;:::-;11824:3;11817:37;11742:118;;:::o;11866:222::-;11959:4;11997:2;11986:9;11982:18;11974:26;;12010:71;12078:1;12067:9;12063:17;12054:6;12010:71;:::i;:::-;11866:222;;;;:::o;12094:748::-;12343:4;12381:3;12370:9;12366:19;12358:27;;12395:71;12463:1;12452:9;12448:17;12439:6;12395:71;:::i;:::-;12476:72;12544:2;12533:9;12529:18;12520:6;12476:72;:::i;:::-;12558;12626:2;12615:9;12611:18;12602:6;12558:72;:::i;:::-;12677:9;12671:4;12667:20;12662:2;12651:9;12647:18;12640:48;12705:130;12830:4;12705:130;:::i;:::-;12697:138;;12094:748;;;;;;:::o;12848:332::-;12969:4;13007:2;12996:9;12992:18;12984:26;;13020:71;13088:1;13077:9;13073:17;13064:6;13020:71;:::i;:::-;13101:72;13169:2;13158:9;13154:18;13145:6;13101:72;:::i;:::-;12848:332;;;;;:::o;13186:373::-;13329:4;13367:2;13356:9;13352:18;13344:26;;13416:9;13410:4;13406:20;13402:1;13391:9;13387:17;13380:47;13444:108;13547:4;13538:6;13444:108;:::i;:::-;13436:116;;13186:373;;;;:::o;13565:210::-;13652:4;13690:2;13679:9;13675:18;13667:26;;13703:65;13765:1;13754:9;13750:17;13741:6;13703:65;:::i;:::-;13565:210;;;;:::o;13781:218::-;13872:4;13910:2;13899:9;13895:18;13887:26;;13923:69;13989:1;13978:9;13974:17;13965:6;13923:69;:::i;:::-;13781:218;;;;:::o;14005:419::-;14171:4;14209:2;14198:9;14194:18;14186:26;;14258:9;14252:4;14248:20;14244:1;14233:9;14229:17;14222:47;14286:131;14412:4;14286:131;:::i;:::-;14278:139;;14005:419;;;:::o;14430:::-;14596:4;14634:2;14623:9;14619:18;14611:26;;14683:9;14677:4;14673:20;14669:1;14658:9;14654:17;14647:47;14711:131;14837:4;14711:131;:::i;:::-;14703:139;;14430:419;;;:::o;14855:::-;15021:4;15059:2;15048:9;15044:18;15036:26;;15108:9;15102:4;15098:20;15094:1;15083:9;15079:17;15072:47;15136:131;15262:4;15136:131;:::i;:::-;15128:139;;14855:419;;;:::o;15280:::-;15446:4;15484:2;15473:9;15469:18;15461:26;;15533:9;15527:4;15523:20;15519:1;15508:9;15504:17;15497:47;15561:131;15687:4;15561:131;:::i;:::-;15553:139;;15280:419;;;:::o;15705:::-;15871:4;15909:2;15898:9;15894:18;15886:26;;15958:9;15952:4;15948:20;15944:1;15933:9;15929:17;15922:47;15986:131;16112:4;15986:131;:::i;:::-;15978:139;;15705:419;;;:::o;16130:::-;16296:4;16334:2;16323:9;16319:18;16311:26;;16383:9;16377:4;16373:20;16369:1;16358:9;16354:17;16347:47;16411:131;16537:4;16411:131;:::i;:::-;16403:139;;16130:419;;;:::o;16555:::-;16721:4;16759:2;16748:9;16744:18;16736:26;;16808:9;16802:4;16798:20;16794:1;16783:9;16779:17;16772:47;16836:131;16962:4;16836:131;:::i;:::-;16828:139;;16555:419;;;:::o;16980:::-;17146:4;17184:2;17173:9;17169:18;17161:26;;17233:9;17227:4;17223:20;17219:1;17208:9;17204:17;17197:47;17261:131;17387:4;17261:131;:::i;:::-;17253:139;;16980:419;;;:::o;17405:222::-;17498:4;17536:2;17525:9;17521:18;17513:26;;17549:71;17617:1;17606:9;17602:17;17593:6;17549:71;:::i;:::-;17405:222;;;;:::o;17633:129::-;17667:6;17694:20;;:::i;:::-;17684:30;;17723:33;17751:4;17743:6;17723:33;:::i;:::-;17633:129;;;:::o;17768:75::-;17801:6;17834:2;17828:9;17818:19;;17768:75;:::o;17849:311::-;17926:4;18016:18;18008:6;18005:30;18002:56;;;18038:18;;:::i;:::-;18002:56;18088:4;18080:6;18076:17;18068:25;;18148:4;18142;18138:15;18130:23;;17849:311;;;:::o;18166:132::-;18233:4;18256:3;18248:11;;18286:4;18281:3;18277:14;18269:22;;18166:132;;;:::o;18304:114::-;18371:6;18405:5;18399:12;18389:22;;18304:114;;;:::o;18424:113::-;18494:4;18526;18521:3;18517:14;18509:22;;18424:113;;;:::o;18543:184::-;18642:11;18676:6;18671:3;18664:19;18716:4;18711:3;18707:14;18692:29;;18543:184;;;;:::o;18733:168::-;18816:11;18850:6;18845:3;18838:19;18890:4;18885:3;18881:14;18866:29;;18733:168;;;;:::o;18907:169::-;18991:11;19025:6;19020:3;19013:19;19065:4;19060:3;19056:14;19041:29;;18907:169;;;;:::o;19082:305::-;19122:3;19141:20;19159:1;19141:20;:::i;:::-;19136:25;;19175:20;19193:1;19175:20;:::i;:::-;19170:25;;19329:1;19261:66;19257:74;19254:1;19251:81;19248:107;;;19335:18;;:::i;:::-;19248:107;19379:1;19376;19372:9;19365:16;;19082:305;;;;:::o;19393:348::-;19433:7;19456:20;19474:1;19456:20;:::i;:::-;19451:25;;19490:20;19508:1;19490:20;:::i;:::-;19485:25;;19678:1;19610:66;19606:74;19603:1;19600:81;19595:1;19588:9;19581:17;19577:105;19574:131;;;19685:18;;:::i;:::-;19574:131;19733:1;19730;19726:9;19715:20;;19393:348;;;;:::o;19747:191::-;19787:4;19807:20;19825:1;19807:20;:::i;:::-;19802:25;;19841:20;19859:1;19841:20;:::i;:::-;19836:25;;19880:1;19877;19874:8;19871:34;;;19885:18;;:::i;:::-;19871:34;19930:1;19927;19923:9;19915:17;;19747:191;;;;:::o;19944:96::-;19981:7;20010:24;20028:5;20010:24;:::i;:::-;19999:35;;19944:96;;;:::o;20046:90::-;20080:7;20123:5;20116:13;20109:21;20098:32;;20046:90;;;:::o;20142:149::-;20178:7;20218:66;20211:5;20207:78;20196:89;;20142:149;;;:::o;20297:126::-;20334:7;20374:42;20367:5;20363:54;20352:65;;20297:126;;;:::o;20429:77::-;20466:7;20495:5;20484:16;;20429:77;;;:::o;20512:281::-;20595:27;20617:4;20595:27;:::i;:::-;20587:6;20583:40;20725:6;20713:10;20710:22;20689:18;20677:10;20674:34;20671:62;20668:88;;;20736:18;;:::i;:::-;20668:88;20776:10;20772:2;20765:22;20555:238;20512:281;;:::o;20799:233::-;20838:3;20861:24;20879:5;20861:24;:::i;:::-;20852:33;;20907:66;20900:5;20897:77;20894:103;;;20977:18;;:::i;:::-;20894:103;21024:1;21017:5;21013:13;21006:20;;20799:233;;;:::o;21038:180::-;21086:77;21083:1;21076:88;21183:4;21180:1;21173:15;21207:4;21204:1;21197:15;21224:180;21272:77;21269:1;21262:88;21369:4;21366:1;21359:15;21393:4;21390:1;21383:15;21410:180;21458:77;21455:1;21448:88;21555:4;21552:1;21545:15;21579:4;21576:1;21569:15;21596:180;21644:77;21641:1;21634:88;21741:4;21738:1;21731:15;21765:4;21762:1;21755:15;21782:117;21891:1;21888;21881:12;21905:117;22014:1;22011;22004:12;22028:117;22137:1;22134;22127:12;22151:117;22260:1;22257;22250:12;22274:117;22383:1;22380;22373:12;22397:102;22438:6;22489:2;22485:7;22480:2;22473:5;22469:14;22465:28;22455:38;;22397:102;;;:::o;22505:170::-;22645:22;22641:1;22633:6;22629:14;22622:46;22505:170;:::o;22681:165::-;22821:17;22817:1;22809:6;22805:14;22798:41;22681:165;:::o;22852:225::-;22992:34;22988:1;22980:6;22976:14;22969:58;23061:8;23056:2;23048:6;23044:15;23037:33;22852:225;:::o;23083:166::-;23223:18;23219:1;23211:6;23207:14;23200:42;23083:166;:::o;23255:182::-;23395:34;23391:1;23383:6;23379:14;23372:58;23255:182;:::o;23443:174::-;23583:26;23579:1;23571:6;23567:14;23560:50;23443:174;:::o;23623:114::-;;:::o;23743:181::-;23883:33;23879:1;23871:6;23867:14;23860:57;23743:181;:::o;23930:164::-;24070:16;24066:1;24058:6;24054:14;24047:40;23930:164;:::o;24100:122::-;24173:24;24191:5;24173:24;:::i;:::-;24166:5;24163:35;24153:63;;24212:1;24209;24202:12;24153:63;24100:122;:::o;24228:116::-;24298:21;24313:5;24298:21;:::i;:::-;24291:5;24288:32;24278:60;;24334:1;24331;24324:12;24278:60;24228:116;:::o;24350:122::-;24423:24;24441:5;24423:24;:::i;:::-;24416:5;24413:35;24403:63;;24462:1;24459;24452:12;24403:63;24350:122;:::o

ipfs://7841baaa5c094483c502bb6ae4d59e224bb21031ed4b73004bd146abf0ff29b5