Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• 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(
•    - function _msgSender()
•    - function _msgData()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
•    - function paused()
•    - function _pause()
•    - function _unpause()
• 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 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 owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _setOwner(address newOwner)
•  contract BoltStaking is Ownable, I ... *
•    - function pause()
•    - function unpause()
•    - function setERC721Address(address con ...
•    - function setERC20ContractAddress(addr ...
•    - function setRate(uint256 _rate)
•    - function setExpiration(uint256 _expir ...
•    - function depositsOf(address account)
•    - function calculateRewards(address acc ...
•    - function calculateReward(address acco ...
•    - function claimRewards(uint256[] calld ...
•    - function deposit(uint256[] calldata t ...
•    - function withdraw(uint256[] calldata ...
•    - function withdrawTokens()
•    - function onERC721Received(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-10-24
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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


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;
}

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;
    }
}

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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());
    }
}

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);
    }
}

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 make 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;
    }
}

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;
    }
}

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);
}

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 tokenId);

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


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 no longer needed starting with Solidity 0.8. 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;
        }
    }
}

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() {
        _setOwner(_msgSender());
    }

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

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

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

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

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

pragma solidity ^0.8.0;


contract BoltStaking is Ownable, IERC721Receiver, ReentrancyGuard, Pausable {
    using EnumerableSet for EnumerableSet.UintSet; 
    
    //addresses 
    address nullAddress = 0x0000000000000000000000000000000000000000;
    address public erc721Address;
    address public erc20Address;

    //uint256's 
    uint256 public expiration; 
    //rate governs how often you receive your token
    uint256 public rate; 
  
    // mappings 
    mapping(address => EnumerableSet.UintSet) private _deposits;
    mapping(address => mapping(uint256 => uint256)) public _depositBlocks;

    constructor(
      address _stakingDestinationAddress,
      uint256 _rate,
      uint256 _expiration,
      address _erc20Address
    ) {
        erc721Address = _stakingDestinationAddress;
        rate = _rate;
        expiration = block.number + _expiration;
        erc20Address = _erc20Address;
        _pause();
    }

    function pause() public onlyOwner {
        _pause();
    }

    function unpause() public onlyOwner {
        _unpause();
    }

/* STAKING MECHANICS */
    function setERC721Address(address contractAddress) public onlyOwner {
        erc721Address = contractAddress;
    }

    function setERC20ContractAddress(address contractAddress) public onlyOwner {
        erc20Address = contractAddress;
    }

    // Set a multiplier for how many tokens to earn each time a block passes.
    function setRate(uint256 _rate) public onlyOwner() {
      rate = _rate;
    }

    // Set this to a block to disable the ability to continue accruing tokens past that block number.
    function setExpiration(uint256 _expiration) public onlyOwner() {
      expiration = block.number + _expiration;
    }

    //check deposit amount. 
    function depositsOf(address account)
      external 
      view 
      returns (uint256[] memory)
    {
      EnumerableSet.UintSet storage depositSet = _deposits[account];
      uint256[] memory tokenIds = new uint256[] (depositSet.length());

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

      return tokenIds;
    }

    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 * 
          (_deposits[account].contains(tokenId) ? 1 : 0) * 
          (Math.min(block.number, expiration) - 
            _depositBlocks[account][tokenId]);
      }

      return rewards;
    }

    //reward amount by address/tokenIds[]
    function calculateReward(address account, uint256 tokenId) 
      public 
      view 
      returns (uint256) 
    {
      require(Math.min(block.number, expiration) > _depositBlocks[account][tokenId], "Invalid blocks");
      return rate * 
          (_deposits[account].contains(tokenId) ? 1 : 0) * 
          (Math.min(block.number, expiration) - 
            _depositBlocks[account][tokenId]);
    }

    //reward claim function 
    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]);
        _depositBlocks[msg.sender][tokenIds[i]] = blockCur;
      }

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

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

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

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

    //withdrawal function.
    function withdraw(uint256[] calldata tokenIds) external whenNotPaused nonReentrant() {
        claimRewards(tokenIds);

        for (uint256 i; i < tokenIds.length; i++) {
            require(
                _deposits[msg.sender].contains(tokenIds[i]),
                "Staking: token not deposited"
            );

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

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

    //withdrawal function.
    function withdrawTokens() external onlyOwner {
        uint256 tokenSupply = IERC20(erc20Address).balanceOf(address(this));
        IERC20(erc20Address).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":"_stakingDestinationAddress","type":"address"},{"internalType":"uint256","name":"_rate","type":"uint256"},{"internalType":"uint256","name":"_expiration","type":"uint256"},{"internalType":"address","name":"_erc20Address","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":"_depositBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"depositsOf","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc20Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"erc721Address","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"expiration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"address","name":"contractAddress","type":"address"}],"name":"setERC20ContractAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"contractAddress","type":"address"}],"name":"setERC721Address","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":"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":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000005381ba6a7cdcc71cbd88cb5acc265d44386af756000000000000000000000000000000000000000000000000006aad65bcabb00000000000000000000000000000000000000000000000000000000000015fe0dc000000000000000000000000110bad3b7c9b50c34d8a196596a513d85b33fc82

-----Decoded View---------------
Arg [0] : _stakingDestinationAddress (address): 0x5381bA6A7CDcc71CBd88cb5acc265D44386AF756
Arg [1] : _rate (uint256): 30027000000000000
Arg [2] : _expiration (uint256): 23060700
Arg [3] : _erc20Address (address): 0x110bAD3b7c9B50C34D8A196596a513D85b33fC82

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 0000000000000000000000005381ba6a7cdcc71cbd88cb5acc265d44386af756
Arg [1] : 000000000000000000000000000000000000000000000000006aad65bcabb000
Arg [2] : 00000000000000000000000000000000000000000000000000000000015fe0dc
Arg [3] : 000000000000000000000000110bad3b7c9b50c34d8a196596a513d85b33fc82

38468:5263:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40658:534;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43509:219;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;41243:413::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;38699:28::-;;;:::i;:::-;;;;;;;:::i;38734:27::-;;;:::i;38874:19::-;;;:::i;39913:80::-;;;;;;:::i;:::-;;:::i;:::-;;39478:65;;;:::i;38788:25::-;;;:::i;40104:119::-;;;;;;:::i;:::-;;:::i;42174:478::-;;;;;;:::i;:::-;;:::i;10117:86::-;;;:::i;:::-;;;;;;;:::i;41694:446::-;;;;;;:::i;:::-;;:::i;37810:94::-;;;:::i;39409:61::-;;;:::i;43305:196::-;;;:::i;37159:87::-;;;:::i;42688:581::-;;;;;;:::i;:::-;;:::i;39576:118::-;;;;;;:::i;:::-;;:::i;39702:124::-;;;;;;:::i;:::-;;:::i;38989:69::-;;;;;;:::i;:::-;;:::i;40261:389::-;;;;;;:::i;:::-;;:::i;38059:192::-;;;;;;:::i;:::-;;:::i;40658:534::-;40773:24;40838:8;:15;40824:30;;;;;;-1:-1:-1;;;40824:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40824:30:0;;40814:40;;40870:9;40865:295;40885:8;:15;40881:1;:19;40865:295;;;40918:15;40936:8;40945:1;40936:11;;;;;;-1:-1:-1;;;40936:11:0;;;;;;;;;;;;;;;40918:29;;41117:14;:23;41132:7;-1:-1:-1;;;;;41117:23:0;-1:-1:-1;;;;;41117:23:0;;;;;;;;;;;;:32;41141:7;41117:32;;;;;;;;;;;;41066:34;41075:12;41089:10;;41066:8;:34::i;:::-;:83;;;;:::i;:::-;-1:-1:-1;;;;;41005:18:0;;;;;;:9;:18;;;;;:36;;41033:7;41005:27;:36::i;:::-;:44;;41048:1;41005:44;;;41044:1;41005:44;40985:65;;:4;;:65;;;;:::i;:::-;:165;;;;:::i;:::-;40960:7;40968:1;40960:10;;;;;;-1:-1:-1;;;40960:10:0;;;;;;;;;;;;;;;;;;:190;-1:-1:-1;40902:3:0;;;;:::i;:::-;;;;40865:295;;;;40658:534;;;;;:::o;43509:219::-;-1:-1:-1;;;43509:219:0;;;;;;;:::o;41243:413::-;-1:-1:-1;;;;;41416:23:0;;41347:7;41416:23;;;:14;:23;;;;;;;;:32;;;;;;;;;41402:10;;41379:34;;41388:12;;41379:8;:34::i;:::-;:69;41371:96;;;;-1:-1:-1;;;41371:96:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;;;;;41615:23:0;;;;;;:14;:23;;;;;;;;:32;;;;;;;;;41587:10;;41564:34;;41573:12;;41564:8;:34::i;:::-;:83;;;;:::i;:::-;-1:-1:-1;;;;;41503:18:0;;;;;;:9;:18;;;;;:36;;41531:7;41503:27;:36::i;:::-;:44;;41546:1;41503:44;;;41542:1;41503:44;41483:65;;:4;;:65;;;;:::i;:::-;:165;;;;:::i;:::-;41476:172;41243:413;-1:-1:-1;;;41243:413:0:o;38699:28::-;;;-1:-1:-1;;;;;38699:28:0;;:::o;38734:27::-;;;-1:-1:-1;;;;;38734:27:0;;:::o;38874:19::-;;;;:::o;39913:80::-;37390:12;:10;:12::i;:::-;-1:-1:-1;;;;;37379:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;37379:23:0;;37371:68;;;;-1:-1:-1;;;37371:68:0;;;;;;;:::i;:::-;39973:4:::1;:12:::0;39913:80::o;39478:65::-;37390:12;:10;:12::i;:::-;-1:-1:-1;;;;;37379:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;37379:23:0;;37371:68;;;;-1:-1:-1;;;37371:68:0;;;;;;;:::i;:::-;39525:10:::1;:8;:10::i;:::-;39478:65::o:0;38788:25::-;;;;:::o;40104:119::-;37390:12;:10;:12::i;:::-;-1:-1:-1;;;;;37379:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;37379:23:0;;37371:68;;;;-1:-1:-1;;;37371:68:0;;;;;;;:::i;:::-;40189:26:::1;40204:11:::0;40189:12:::1;:26;:::i;:::-;40176:10;:39:::0;-1:-1:-1;40104:119:0:o;42174:478::-;10443:8;:6;:8::i;:::-;10442:9;10434:38;;;;-1:-1:-1;;;10434:38:0;;;;;;;:::i;:::-;42276:13:::1;::::0;-1:-1:-1;;;;;42276:13:0::1;42262:10;:27;;42254:55;;;;-1:-1:-1::0;;;42254:55:0::1;;;;;;;:::i;:::-;42320:22;42333:8;;42320:12;:22::i;:::-;42360:9;42355:290;42371:19:::0;;::::1;42355:290;;;42420:13;::::0;-1:-1:-1;;;;;42420:13:0::1;42412:39;42470:10;42507:4;42531:8:::0;;42540:1;42531:11;;::::1;;;-1:-1:-1::0;;;42531:11:0::1;;;;;;;;;;;;;;;42412:166;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;42595:38;42621:8;;42630:1;42621:11;;;;;-1:-1:-1::0;;;42621:11:0::1;;;;;;;;;42605:10;42595:21;::::0;;;:9:::1;42621:11;42595:21:::0;;;;;;;;42621:11;::::1;;;::::0;-1:-1:-1;42595:25:0::1;:38::i;:::-;-1:-1:-1::0;42392:3:0;::::1;::::0;::::1;:::i;:::-;;;;42355:290;;;;42174:478:::0;;:::o;10117:86::-;10188:7;;;;10117:86;:::o;41694:446::-;10443:8;:6;:8::i;:::-;10442:9;10434:38;;;;-1:-1:-1;;;10434:38:0;;;;;;;:::i;:::-;41775:14:::1;41799:16:::0;41818:34:::1;41827:12;41841:10;;41818:8;:34::i;:::-;41799:53;;41868:9;41863:174;41879:19:::0;;::::1;41863:174;;;41926:40;41942:10;41954:8;;41963:1;41954:11;;;;;-1:-1:-1::0;;;41954:11:0::1;;;;;;;;;;;;;;;41926:15;:40::i;:::-;41916:50;::::0;;::::1;:::i;:::-;41992:10;41977:26;::::0;;;:14:::1;:26;::::0;;;;41916:50;;-1:-1:-1;42019:8:0;;41977:26;42004:8;;42013:1;42004:11;;::::1;;;-1:-1:-1::0;;;42004:11:0::1;;;;;;;;;;;;;;;41977:39;;;;;;;;;;;:50;;;;41900:3;;;;;:::i;:::-;;;;41863:174;;;-1:-1:-1::0;42051:10:0;;42047:86:::1;;42081:12;::::0;;42074:49:::1;::::0;-1:-1:-1;;;42074:49:0;;-1:-1:-1;;;;;42081:12:0;;::::1;::::0;42074:29:::1;::::0;:49:::1;::::0;42104:10:::1;::::0;42116:6;;42074:49:::1;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;42047:86;10483:1;;41694:446:::0;;:::o;37810:94::-;37390:12;:10;:12::i;:::-;-1:-1:-1;;;;;37379:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;37379:23:0;;37371:68;;;;-1:-1:-1;;;37371:68:0;;;;;;;:::i;:::-;37875:21:::1;37893:1;37875:9;:21::i;39409:61::-:0;37390:12;:10;:12::i;:::-;-1:-1:-1;;;;;37379:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;37379:23:0;;37371:68;;;;-1:-1:-1;;;37371:68:0;;;;;;;:::i;:::-;39454:8:::1;:6;:8::i;43305:196::-:0;37390:12;:10;:12::i;:::-;-1:-1:-1;;;;;37379:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;37379:23:0;;37371:68;;;;-1:-1:-1;;;37371:68:0;;;;;;;:::i;:::-;43390:12:::1;::::0;;43383:45:::1;::::0;-1:-1:-1;;;43383:45:0;;43361:19:::1;::::0;-1:-1:-1;;;;;43390:12:0;;::::1;::::0;43383:30:::1;::::0;:45:::1;::::0;43422:4:::1;::::0;43383:45:::1;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43446:12;::::0;;43439:54:::1;::::0;-1:-1:-1;;;43439:54:0;;43361:67;;-1:-1:-1;;;;;;43446:12:0::1;::::0;43439:29:::1;::::0;:54:::1;::::0;43469:10:::1;::::0;43361:67;;43439:54:::1;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;37450:1;43305:196::o:0;37159:87::-;37205:7;37232:6;-1:-1:-1;;;;;37232:6:0;37159:87;:::o;42688:581::-;10443:8;:6;:8::i;:::-;10442:9;10434:38;;;;-1:-1:-1;;;10434:38:0;;;;;;;:::i;:::-;14147:1:::1;14743:7;;:19;;14735:63;;;;-1:-1:-1::0;;;14735:63:0::1;;;;;;;:::i;:::-;14147:1;14876:7;:18:::0;42784:22:::2;42797:8:::0;;42784:12:::2;:22::i;:::-;42824:9;42819:443;42835:19:::0;;::::2;42819:443;;;42902:43;42933:8;;42942:1;42933:11;;;;;-1:-1:-1::0;;;42933:11:0::2;;;;;;;;;42912:10;42902:21;::::0;;;:9:::2;42933:11;42902:21:::0;;;;;;;;42933:11;::::2;;;::::0;-1:-1:-1;42902:30:0::2;:43::i;:::-;42876:133;;;;-1:-1:-1::0;;;42876:133:0::2;;;;;;;:::i;:::-;43026:41;43055:8;;43064:1;43055:11;;;;;-1:-1:-1::0;;;43055:11:0::2;;;;;;;;;43036:10;43026:21;::::0;;;:9:::2;43055:11;43026:21:::0;;;;;;;;43055:11;::::2;;;::::0;-1:-1:-1;43026:28:0::2;:41::i;:::-;-1:-1:-1::0;43092:13:0::2;::::0;-1:-1:-1;;;;;43092:13:0::2;43084:39;43150:4;43174:10;43203:8:::0;;43212:1;43203:11;;::::2;;;-1:-1:-1::0;;;43203:11:0::2;;;;;;;;;;;;;;;43084:166;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;42856:3;;;;;:::i;:::-;;;;42819:443;;;-1:-1:-1::0;;14103:1:0::1;15055:22:::0;;-1:-1:-1;42688:581:0:o;39576:118::-;37390:12;:10;:12::i;:::-;-1:-1:-1;;;;;37379:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;37379:23:0;;37371:68;;;;-1:-1:-1;;;37371:68:0;;;;;;;:::i;:::-;39655:13:::1;:31:::0;;-1:-1:-1;;;;;;39655:31:0::1;-1:-1:-1::0;;;;;39655:31:0;;;::::1;::::0;;;::::1;::::0;;39576:118::o;39702:124::-;37390:12;:10;:12::i;:::-;-1:-1:-1;;;;;37379:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;37379:23:0;;37371:68;;;;-1:-1:-1;;;37371:68:0;;;;;;;:::i;:::-;39788:12:::1;:30:::0;;-1:-1:-1;;;;;;39788:30:0::1;-1:-1:-1::0;;;;;39788:30:0;;;::::1;::::0;;;::::1;::::0;;39702:124::o;38989:69::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;40261:389::-;-1:-1:-1;;;;;40419:18:0;;40376:40;40419:18;;;:9;:18;;;;;40344:16;;40489:19;40419:18;40489:17;:19::i;:::-;40474:35;;;;;;-1:-1:-1;;;40474:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;40474:35:0;;40446:63;;40525:9;40520:97;40540:19;:10;:17;:19::i;:::-;40536:1;:23;40520:97;;;40591:16;:10;40605:1;40591:13;:16::i;:::-;40577:8;40586:1;40577:11;;;;;;-1:-1:-1;;;40577:11:0;;;;;;;;;;;;;;;;;;:30;40561:3;;;;:::i;:::-;;;;40520:97;;;-1:-1:-1;40634:8:0;-1:-1:-1;;40261:389:0;;;;:::o;38059:192::-;37390:12;:10;:12::i;:::-;-1:-1:-1;;;;;37379:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;37379:23:0;;37371:68;;;;-1:-1:-1;;;37371:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;38148:22:0;::::1;38140:73;;;;-1:-1:-1::0;;;38140:73:0::1;;;;;;;:::i;:::-;38224:19;38234:8;38224:9;:19::i;:::-;38059:192:::0;:::o;11677:106::-;11735:7;11766:1;11762;:5;:13;;11774:1;11762:13;;;-1:-1:-1;11770:1:0;;11677:106;-1:-1:-1;11677:106:0:o;25872:146::-;25949:4;25973:37;25983:3;26003:5;25973:9;:37::i;6117:98::-;6197:10;6117:98;:::o;11176:120::-;10720:8;:6;:8::i;:::-;10712:41;;;;-1:-1:-1;;;10712:41:0;;;;;;;:::i;:::-;11235:7:::1;:15:::0;;-1:-1:-1;;11235:15:0::1;::::0;;11266:22:::1;11275:12;:10;:12::i;:::-;11266:22;;;;;;:::i;:::-;;;;;;;;11176:120::o:0;25342:131::-;25409:4;25433:32;25438:3;25458:5;25433:4;:32::i;38259:173::-;38315:16;38334:6;;-1:-1:-1;;;;;38351:17:0;;;-1:-1:-1;;;;;;38351:17:0;;;;;;38384:40;;38334:6;;;;;;;38384:40;;38315:16;38384:40;38259:173;;:::o;10917:118::-;10443:8;:6;:8::i;:::-;10442:9;10434:38;;;;-1:-1:-1;;;10434:38:0;;;;;;;:::i;:::-;10977:7:::1;:14:::0;;-1:-1:-1;;10977:14:0::1;10987:4;10977:14;::::0;;11007:20:::1;11014:12;:10;:12::i;25649:137::-:0;25719:4;25743:35;25751:3;25771:5;25743:7;:35::i;26104:114::-;26164:7;26191:19;26199:3;26191:7;:19::i;26572:137::-;26643:7;26678:22;26682:3;26694:5;26678:3;:22::i;18835:129::-;18908:4;18932:19;;;:12;;;;;:19;;;;;;:24;;;18835:129::o;16739:414::-;16802:4;16824:21;16834:3;16839:5;16824:9;:21::i;:::-;16819:327;;-1:-1:-1;16862:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;17045:18;;17023:19;;;:12;;;:19;;;;;;:40;;;;17078:11;;16819:327;-1:-1:-1;17129:5:0;17122:12;;17329:1420;17395:4;17534:19;;;:12;;;:19;;;;;;17570:15;;17566:1176;;17945:21;17969:14;17982:1;17969:10;:14;:::i;:::-;18018:18;;17945:38;;-1:-1:-1;17998:17:0;;18018:22;;18039:1;;18018:22;:::i;:::-;17998:42;;18074:13;18061:9;:26;18057:405;;18108:17;18128:3;:11;;18140:9;18128:22;;;;;;-1:-1:-1;;;18128:22:0;;;;;;;;;;;;;;;;;18108:42;;18282:9;18253:3;:11;;18265:13;18253:26;;;;;;-1:-1:-1;;;18253:26:0;;;;;;;;;;;;;;;;;;;;:38;;;;18367:23;;;:12;;;:23;;;;;:36;;;18057:405;18543:17;;:3;;:17;;;-1:-1:-1;;;18543:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;18638:3;:12;;:19;18651:5;18638:19;;;;;;;;;;;18631:26;;;18681:4;18674:11;;;;;;;17566:1176;18725:5;18718:12;;;;;19050:109;19133:18;;19050:109::o;19513:120::-;19580:7;19607:3;:11;;19619:5;19607:18;;;;;;-1:-1:-1;;;19607:18:0;;;;;;;;;;;;;;;;;19600:25;;19513:120;;;;:::o;14:175:1:-;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:862::-;;;;;;579:3;567:9;558:7;554:23;550:33;547:2;;;601:6;593;586:22;547:2;629:31;650:9;629:31;:::i;:::-;619:41;;679:40;715:2;704:9;700:18;679:40;:::i;:::-;669:50;;766:2;755:9;751:18;738:32;728:42;;821:2;810:9;806:18;793:32;844:18;885:2;877:6;874:14;871:2;;;906:6;898;891:22;871:2;949:6;938:9;934:22;924:32;;994:7;987:4;983:2;979:13;975:27;965:2;;1021:6;1013;1006:22;965:2;1066;1053:16;1092:2;1084:6;1081:14;1078:2;;;1113:6;1105;1098:22;1078:2;1163:7;1158:2;1149:6;1145:2;1141:15;1137:24;1134:37;1131:2;;;1189:6;1181;1174:22;1131:2;537:722;;;;-1:-1:-1;537:722:1;;-1:-1:-1;1225:2:1;1217:11;;1247:6;537:722;-1:-1:-1;;;537:722:1:o;1264:1234::-;;;1418:2;1406:9;1397:7;1393:23;1389:32;1386:2;;;1439:6;1431;1424:22;1386:2;1467:31;1488:9;1467:31;:::i;:::-;1457:41;;1517:2;1570;1559:9;1555:18;1542:32;1593:18;1634:2;1626:6;1623:14;1620:2;;;1655:6;1647;1640:22;1620:2;1698:6;1687:9;1683:22;1673:32;;1743:7;1736:4;1732:2;1728:13;1724:27;1714:2;;1770:6;1762;1755:22;1714:2;1811;1798:16;1833:2;1829;1826:10;1823:2;;;1839:18;;:::i;:::-;1886:2;1882;1878:11;1918:2;1912:9;1969:2;1964;1956:6;1952:15;1948:24;2022:6;2010:10;2007:22;2002:2;1990:10;1987:18;1984:46;1981:2;;;2033:18;;:::i;:::-;2069:2;2062:22;2119:18;;;2153:15;;;;-1:-1:-1;2188:11:1;;;2218;;;2214:20;;2211:33;-1:-1:-1;2208:2:1;;;2262:6;2254;2247:22;2208:2;2289:6;2280:15;;2304:163;2318:2;2315:1;2312:9;2304:163;;;2375:17;;2363:30;;2336:1;2329:9;;;;;2413:12;;;;2445;;2304:163;;;2308:3;2486:6;2476:16;;;;;;;;1376:1122;;;;;:::o;2503:266::-;;;2632:2;2620:9;2611:7;2607:23;2603:32;2600:2;;;2653:6;2645;2638:22;2600:2;2681:31;2702:9;2681:31;:::i;:::-;2671:41;2759:2;2744:18;;;;2731:32;;-1:-1:-1;;;2590:179:1:o;2774:666::-;;;2921:2;2909:9;2900:7;2896:23;2892:32;2889:2;;;2942:6;2934;2927:22;2889:2;2987:9;2974:23;3016:18;3057:2;3049:6;3046:14;3043:2;;;3078:6;3070;3063:22;3043:2;3121:6;3110:9;3106:22;3096:32;;3166:7;3159:4;3155:2;3151:13;3147:27;3137:2;;3193:6;3185;3178:22;3137:2;3238;3225:16;3264:2;3256:6;3253:14;3250:2;;;3285:6;3277;3270:22;3250:2;3344:7;3339:2;3333;3325:6;3321:15;3317:2;3313:24;3309:33;3306:46;3303:2;;;3370:6;3362;3355:22;3303:2;3406;3398:11;;;;;3428:6;;-1:-1:-1;2879:561:1;;-1:-1:-1;;;;2879:561:1:o;3445:297::-;;3565:2;3553:9;3544:7;3540:23;3536:32;3533:2;;;3586:6;3578;3571:22;3533:2;3623:9;3617:16;3676:5;3669:13;3662:21;3655:5;3652:32;3642:2;;3703:6;3695;3688:22;3747:190;;3859:2;3847:9;3838:7;3834:23;3830:32;3827:2;;;3880:6;3872;3865:22;3827:2;-1:-1:-1;3908:23:1;;3817:120;-1:-1:-1;3817:120:1:o;3942:194::-;;4065:2;4053:9;4044:7;4040:23;4036:32;4033:2;;;4086:6;4078;4071:22;4033:2;-1:-1:-1;4114:16:1;;4023:113;-1:-1:-1;4023:113:1:o;4141:203::-;-1:-1:-1;;;;;4305:32:1;;;;4287:51;;4275:2;4260:18;;4242:102::o;4349:558::-;-1:-1:-1;;;;;4672:15:1;;;4654:34;;4724:15;;;;4719:2;4704:18;;4697:43;4771:2;4756:18;;4749:34;;;;4819:3;4814:2;4799:18;;4792:31;;;4349:558;4839:19;;;4832:33;4634:3;4882:19;;4606:301::o;4912:274::-;-1:-1:-1;;;;;5104:32:1;;;;5086:51;;5168:2;5153:18;;5146:34;5074:2;5059:18;;5041:145::o;5191:635::-;5362:2;5414:21;;;5484:13;;5387:18;;;5506:22;;;5191:635;;5362:2;5585:15;;;;5559:2;5544:18;;;5191:635;5631:169;5645:6;5642:1;5639:13;5631:169;;;5706:13;;5694:26;;5775:15;;;;5740:12;;;;5667:1;5660:9;5631:169;;;-1:-1:-1;5817:3:1;;5342:484;-1:-1:-1;;;;;;5342:484:1:o;5831:187::-;5996:14;;5989:22;5971:41;;5959:2;5944:18;;5926:92::o;6023:202::-;-1:-1:-1;;;;;;6185:33:1;;;;6167:52;;6155:2;6140:18;;6122:103::o;6230:344::-;6432:2;6414:21;;;6471:2;6451:18;;;6444:30;-1:-1:-1;;;6505:2:1;6490:18;;6483:50;6565:2;6550:18;;6404:170::o;6579:339::-;6781:2;6763:21;;;6820:2;6800:18;;;6793:30;-1:-1:-1;;;6854:2:1;6839:18;;6832:45;6909:2;6894:18;;6753:165::o;6923:402::-;7125:2;7107:21;;;7164:2;7144:18;;;7137:30;7203:34;7198:2;7183:18;;7176:62;-1:-1:-1;;;7269:2:1;7254:18;;7247:36;7315:3;7300:19;;7097:228::o;7330:340::-;7532:2;7514:21;;;7571:2;7551:18;;;7544:30;-1:-1:-1;;;7605:2:1;7590:18;;7583:46;7661:2;7646:18;;7504:166::o;7675:356::-;7877:2;7859:21;;;7896:18;;;7889:30;7955:34;7950:2;7935:18;;7928:62;8022:2;8007:18;;7849:182::o;8036:352::-;8238:2;8220:21;;;8277:2;8257:18;;;8250:30;8316;8311:2;8296:18;;8289:58;8379:2;8364:18;;8210:178::o;8393:355::-;8595:2;8577:21;;;8634:2;8614:18;;;8607:30;8673:33;8668:2;8653:18;;8646:61;8739:2;8724:18;;8567:181::o;8753:338::-;8955:2;8937:21;;;8994:2;8974:18;;;8967:30;-1:-1:-1;;;9028:2:1;9013:18;;9006:44;9082:2;9067:18;;8927:164::o;9096:177::-;9242:25;;;9230:2;9215:18;;9197:76::o;9278:128::-;;9349:1;9345:6;9342:1;9339:13;9336:2;;;9355:18;;:::i;:::-;-1:-1:-1;9391:9:1;;9326:80::o;9411:168::-;;9517:1;9513;9509:6;9505:14;9502:1;9499:21;9494:1;9487:9;9480:17;9476:45;9473:2;;;9524:18;;:::i;:::-;-1:-1:-1;9564:9:1;;9463:116::o;9584:125::-;;9652:1;9649;9646:8;9643:2;;;9657:18;;:::i;:::-;-1:-1:-1;9694:9:1;;9633:76::o;9714:135::-;;-1:-1:-1;;9774:17:1;;9771:2;;;9794:18;;:::i;:::-;-1:-1:-1;9841:1:1;9830:13;;9761:88::o;9854:127::-;9915:10;9910:3;9906:20;9903:1;9896:31;9946:4;9943:1;9936:15;9970:4;9967:1;9960:15;9986:127;10047:10;10042:3;10038:20;10035:1;10028:31;10078:4;10075:1;10068:15;10102:4;10099:1;10092:15

ipfs://1cbea4af1bf08ba676f46559b451979ba35b9351173481a9a900e40ac06f0cf5