Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-04-19
*/

pragma solidity 0.8.0;

// SPDX-License-Identifier: MIT



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

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

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

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

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

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

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

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




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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







/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

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

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

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

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

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

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

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




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




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




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

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






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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _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);
    }
}

/**
 * @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() internal {
        _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;
    }
}



interface ISwapContractMin {
    function getCurrentPriceLP() external view returns (uint256);

    function getDepositFeeRate(address _token, uint256 _amountOfFloat)
        external
        view
        returns (uint256);

    function getFloatReserve(address _tokenA, address _tokenB)
        external
        view
        returns (uint256 reserveA, uint256 reserveB);
}











contract ChefLinkMaki is Ownable, ReentrancyGuard {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;

    // The Skybridge contract.
    ISwapContractMin public immutable swapContract;
    // The reward token.
    IERC20 public immutable rewardToken;
    // The staked token.
    IERC20 public immutable stakedToken;
    // The BTCT address.
    address public immutable BTCT_ADDR;
    // Accrued token per share.
    uint256 public accTokenPerShare;
    // The block number when token distribute ends.
    uint256 public bonusEndBlock;
    // The block number when token distribute starts.
    uint256 public startBlock;
    // The block number of the last pool update.
    uint256 public lastRewardBlock;
    // Tokens per block.
    uint256 public rewardPerBlock;
    // default param that for rewardPerBlock.
    uint256 public defaultRewardPerBlock;
    // the maximum size of rewardPerBlock.
    uint256 public maxRewardPerBlock;
    // A falg for dynamic changing ths rewardPerBlock.
    bool public isDynamic = true;
    // The flag for active BTC pool.
    bool public isDynamicBTC;
    // The flag for active BTCT pool.
    bool public isDynamicBTCT;
    // latest tilt size which is updated when updated pool.
    uint256 public latestTilt;
    // A number of staked token amount
    uint256 public totalStaked;
    // Info of each user that stakes tokens (stakedToken).
    mapping(address => UserInfo) public userInfo;

    struct UserInfo {
        uint256 amount; // How many staked tokens the user has provided
        uint256 rewardDebt; // Reward debt
    }

    event AdminTokenRecovery(address tokenRecovered, uint256 amount);
    event Deposit(address indexed user, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 amount);
    event EmergencyRewardWithdraw(uint256 amount);
    event NewStartAndEndBlocks(uint256 startBlock, uint256 endBlock);
    event NewRewardPerBlock(uint256 rewardPerBlock);
    event NewPoolLimit(uint256 poolLimitPerUser);
    event RewardsStop(uint256 blockNumber);
    event Withdraw(address indexed user, uint256 amount);

    constructor(
        IERC20 _stakedToken,
        IERC20 _rewardToken,
        ISwapContractMin _swapContract,
        address _btct,
        uint256 _rewardPerBlock,
        uint256 _maxRewardPerBlock,
        uint256 _startBlock,
        uint256 _bonusEndBlock
    ) public {
        stakedToken = _stakedToken;
        rewardToken = _rewardToken;
        rewardPerBlock = _rewardPerBlock;
        defaultRewardPerBlock = rewardPerBlock;
        require(_maxRewardPerBlock >= _rewardPerBlock);
        maxRewardPerBlock = _maxRewardPerBlock;
        startBlock = _startBlock;
        bonusEndBlock = _bonusEndBlock;
        // Set the lastRewardBlock as the startBlock
        lastRewardBlock = startBlock;
        // Sst Skybridge contract
        swapContract = _swapContract;
        // Set BTCT
        BTCT_ADDR = _btct;
    }

    /**
     * @notice Deposit staked tokens and collect reward tokens (if any)
     * @param _amount: amount to withdraw (in rewardToken)
     */
    function deposit(uint256 _amount) external nonReentrant {
        UserInfo storage user = userInfo[msg.sender];
        _updatePool();

        if (user.amount != 0) {
            uint256 pending = user.amount.mul(accTokenPerShare).div(1e12).sub(
                user.rewardDebt
            );
            if (pending > 0) {
                rewardToken.safeTransfer(address(msg.sender), pending);
            }
        }

        if (_amount != 0) {
            user.amount = user.amount.add(_amount);
            stakedToken.safeTransferFrom(
                address(msg.sender),
                address(this),
                _amount
            );
        }

        user.rewardDebt = user.amount.mul(accTokenPerShare).div(1e12);
        totalStaked = totalStaked.add(_amount);
        emit Deposit(msg.sender, _amount);
    }

    /**
     * @notice Withdraw staked tokens and collect reward tokens
     * @param _amount: amount to withdraw (in rewardToken)
     */
    function withdraw(uint256 _amount) external nonReentrant {
        UserInfo storage user = userInfo[msg.sender];
        require(user.amount >= _amount, "Amount to withdraw too high");

        _updatePool();

        uint256 pending = user.amount.mul(accTokenPerShare).div(1e12).sub(
            user.rewardDebt
        );

        if (_amount != 0) {
            user.amount = user.amount.sub(_amount);
            stakedToken.safeTransfer(address(msg.sender), _amount);
        }

        if (pending != 0) {
            rewardToken.safeTransfer(address(msg.sender), pending);
        }

        user.rewardDebt = user.amount.mul(accTokenPerShare).div(1e12);
        totalStaked = totalStaked.sub(_amount);
        emit Withdraw(msg.sender, _amount);
    }

    /**
     * @notice Withdraw staked tokens without caring about rewards rewards
     * @dev Needs to be for emergency.
     */
    function emergencyWithdraw() external nonReentrant {
        UserInfo storage user = userInfo[msg.sender];
        uint256 amountToTransfer = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;

        if (amountToTransfer != 0) {
            stakedToken.safeTransfer(address(msg.sender), amountToTransfer);
        }
        totalStaked = totalStaked.sub(amountToTransfer);

        emit EmergencyWithdraw(msg.sender, user.amount);
    }

    /**
     * @notice Stop rewards
     * @dev Only callable by owner. Needs to be for emergency.
     */
    function emergencyRewardWithdraw(uint256 _amount) external onlyOwner {
        rewardToken.safeTransfer(address(msg.sender), _amount);
        emit EmergencyRewardWithdraw(_amount);
    }

    /**
     * @notice It allows the admin to recover wrong tokens sent to the contract
     * @param _tokenAddress: the address of the token to withdraw
     * @param _tokenAmount: the number of tokens to withdraw
     * @dev This function is only callable by admin.
     */
    function recoverWrongTokens(address _tokenAddress, uint256 _tokenAmount)
        external
        onlyOwner
    {
        require(
            _tokenAddress != address(stakedToken),
            "Cannot be staked token"
        );
        require(
            _tokenAddress != address(rewardToken),
            "Cannot be reward token"
        );

        IERC20(_tokenAddress).safeTransfer(address(msg.sender), _tokenAmount);

        emit AdminTokenRecovery(_tokenAddress, _tokenAmount);
    }

    /**
     * @notice Stop rewards
     * @dev Only callable by owner
     */
    function stopReward() external onlyOwner {
        bonusEndBlock = block.number;
    }

    /**
     * @notice Update reward per block
     * @dev Only callable by owner.
     * @param _rewardPerBlock: the reward per block
     * @param _maxRewardPerBlock: the max nubmer of reward per block
     * @param _isDynamic: the flag for enalble dynamic changing the rewardPerBlock
     */
    function updateRewardPerBlock(
        uint256 _rewardPerBlock,
        uint256 _maxRewardPerBlock,
        bool _isDynamic
    ) external onlyOwner {
        require(_rewardPerBlock >= 1e17);
        require(_rewardPerBlock <= 3e18);
        require(_maxRewardPerBlock >= _rewardPerBlock);
        _updatePool();
        rewardPerBlock = _rewardPerBlock;
        defaultRewardPerBlock = rewardPerBlock;
        maxRewardPerBlock = _maxRewardPerBlock;
        isDynamic = _isDynamic;
        if (!_isDynamic) {
            isDynamicBTC = false;
            isDynamicBTCT = false;
        }
        emit NewRewardPerBlock(_rewardPerBlock);
    }

    /**
     * @notice It allows the admin to update start and end blocks
     * @dev This function is only callable by owner.
     * @param _startBlock: the new start block
     * @param _bonusEndBlock: the new end block
     */
    function updateStartAndEndBlocks(
        uint256 _startBlock,
        uint256 _bonusEndBlock
    ) external onlyOwner {
        require(block.number < startBlock, "Pool has started");
        require(
            _startBlock < _bonusEndBlock,
            "New startBlock must be lower than new endBlock"
        );
        require(
            block.number < _startBlock,
            "New startBlock must be higher than current block"
        );

        startBlock = _startBlock;
        bonusEndBlock = _bonusEndBlock;

        // Set the lastRewardBlock as the startBlock
        lastRewardBlock = startBlock;

        emit NewStartAndEndBlocks(_startBlock, _bonusEndBlock);
    }

    /**
     * @notice Update bonusEndBlock of the given pool to be up-to-date.
     * @param _bonusEndBlock: next bonusEndBlock
     */

    function updateEndBlocks(uint256 _bonusEndBlock) external onlyOwner {
        require(
            block.number < _bonusEndBlock,
            "New bonusEndBlock must be higher than current height"
        );
        bonusEndBlock = _bonusEndBlock;
    }

    /**
     * @notice View function to see pending reward on frontend.
     * @param _user: user address
     * @return Pending reward for a given user
     */
    function pendingReward(address _user) external view returns (uint256) {
        UserInfo storage user = userInfo[_user];
        uint256 stakedTokenSupply = totalStaked;
        if (block.number > lastRewardBlock && stakedTokenSupply != 0) {
            uint256 multiplier = _getMultiplier(lastRewardBlock, block.number);
            uint256 tokenReward = multiplier.mul(rewardPerBlock);
            uint256 adjustedTokenPerShare = accTokenPerShare.add(
                tokenReward.mul(1e12).div(stakedTokenSupply)
            );
            return
                user.amount.mul(adjustedTokenPerShare).div(1e12).sub(
                    user.rewardDebt
                );
        } else {
            return
                user.amount.mul(accTokenPerShare).div(1e12).sub(
                    user.rewardDebt
                );
        }
    }

    /**
     * @notice Update reward variables of the given pool to be up-to-date.
     */
    function _updatePool() internal {
        if (block.number <= lastRewardBlock) {
            return;
        }
        uint256 stakedTokenSupply = stakedToken.balanceOf(address(this));

        if (stakedTokenSupply == 0) {
            lastRewardBlock = block.number;
            return;
        }
        uint256 multiplier = _getMultiplier(lastRewardBlock, block.number);
        uint256 tokenReward = multiplier.mul(rewardPerBlock);
        accTokenPerShare = accTokenPerShare.add(
            tokenReward.mul(1e12).div(stakedTokenSupply)
        );
        if (isDynamic) _updateRewardPerBlock();
        lastRewardBlock = block.number;
    }

    /**
     * @notice View function to see next expected rewardPerBlock on frontend.
     * @param _token: token address which is supported on Swingby Skybridge.
     * @param _amountOfFloat: a float amount when deposited on skybridge in the future.
     */

    function getExpectedRewardPerBlock(address _token, uint256 _amountOfFloat)
        public
        view
        returns (
            uint256 updatedRewards,
            uint256 reserveBTC,
            uint256 reserveBTCT,
            uint256 tilt
        )
    {
        uint256 blocks = block.number - lastRewardBlock != 0
            ? block.number.sub(lastRewardBlock)
            : 1;

        if (blocks > 50) blocks = 50;

        updatedRewards = rewardPerBlock;
        (reserveBTC, reserveBTCT) = swapContract.getFloatReserve(
            address(0),
            BTCT_ADDR
        );

        require(_token == address(0x0) || _token == BTCT_ADDR);

        if (_token == address(0x0)) reserveBTC = reserveBTC.add(_amountOfFloat);
        else reserveBTCT = reserveBTCT.add(_amountOfFloat);

        tilt = (reserveBTC >= reserveBTCT)
            ? reserveBTC.sub(reserveBTCT)
            : reserveBTCT.sub(reserveBTC);

        if ((isDynamicBTC || isDynamicBTCT) && isDynamic)
            if (latestTilt > tilt) {
                updatedRewards = rewardPerBlock.add(
                    latestTilt.sub(tilt).mul(1e10).div(blocks)
                ); // moved == decimals 8
            } else {
                if (tilt.sub(latestTilt).mul(1e10) <= rewardPerBlock)
                    updatedRewards = rewardPerBlock.sub(
                        tilt.sub(latestTilt).mul(1e10).div(blocks)
                    ); // moved == decimals 8
                else updatedRewards = defaultRewardPerBlock;
            }

        if (updatedRewards >= maxRewardPerBlock) {
            updatedRewards = maxRewardPerBlock;
        }
        if (updatedRewards <= defaultRewardPerBlock) {
            updatedRewards = defaultRewardPerBlock;
        }
        return (updatedRewards, reserveBTC, reserveBTCT, tilt);
    }

    /**
     * @notice Update rewardPerBlock
     */
    function _updateRewardPerBlock() internal {
        (
            uint256 updatedRewards,
            uint256 reserveBTC,
            uint256 reserveBTCT,
            uint256 tilt
        ) = getExpectedRewardPerBlock(address(0x0), 0); // check the current numbers.

        rewardPerBlock = updatedRewards;

        // Reback the rate is going to be posive after reached to a threshold.
        if (reserveBTC >= reserveBTCT && isDynamicBTC) {
            // Disable additonal rewards rate for btc
            isDynamicBTC = false;
            rewardPerBlock = defaultRewardPerBlock;
        }

        // Reback the rate is going to be negative after reached to a threshold.
        if (reserveBTCT >= reserveBTC && isDynamicBTCT) {
            // Disable additonal rewards rate for btct
            isDynamicBTCT = false;
            rewardPerBlock = defaultRewardPerBlock;
        }

        // Check the deposit fees rate for checking the tilt of float balances
        uint256 feesForDepositBTC = swapContract.getDepositFeeRate(
            address(0x0),
            0
        );
        uint256 feesForDepositBTCT = swapContract.getDepositFeeRate(
            BTCT_ADDR,
            0
        );

        // if the deposit fees for BTC are exist, have to be activated isDynamicBTCT
        if (feesForDepositBTC != 0) {
            isDynamicBTCT = true;
        }
        // if the deposit fees for BTC are exist, have to be activated isDynamicBTC
        if (feesForDepositBTCT != 0) {
            isDynamicBTC = true;
        }
        latestTilt = tilt;
    }

    /**
     * @notice Return reward multiplier over the given _from to _to block.
     * @param _from: block to start
     * @param _to: block to finish
     */
    function _getMultiplier(uint256 _from, uint256 _to)
        internal
        view
        returns (uint256)
    {
        if (_to <= bonusEndBlock) {
            return _to.sub(_from);
        } else if (_from >= bonusEndBlock) {
            return 0;
        } else {
            return bonusEndBlock.sub(_from);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_stakedToken","type":"address"},{"internalType":"contract IERC20","name":"_rewardToken","type":"address"},{"internalType":"contract ISwapContractMin","name":"_swapContract","type":"address"},{"internalType":"address","name":"_btct","type":"address"},{"internalType":"uint256","name":"_rewardPerBlock","type":"uint256"},{"internalType":"uint256","name":"_maxRewardPerBlock","type":"uint256"},{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"uint256","name":"_bonusEndBlock","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"tokenRecovered","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"AdminTokenRecovery","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyRewardWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"poolLimitPerUser","type":"uint256"}],"name":"NewPoolLimit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"rewardPerBlock","type":"uint256"}],"name":"NewRewardPerBlock","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"startBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"endBlock","type":"uint256"}],"name":"NewStartAndEndBlocks","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"RewardsStop","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"BTCT_ADDR","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accTokenPerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"bonusEndBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"defaultRewardPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"emergencyRewardWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_amountOfFloat","type":"uint256"}],"name":"getExpectedRewardPerBlock","outputs":[{"internalType":"uint256","name":"updatedRewards","type":"uint256"},{"internalType":"uint256","name":"reserveBTC","type":"uint256"},{"internalType":"uint256","name":"reserveBTCT","type":"uint256"},{"internalType":"uint256","name":"tilt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isDynamic","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isDynamicBTC","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isDynamicBTCT","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastRewardBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestTilt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxRewardPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_user","type":"address"}],"name":"pendingReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_tokenAddress","type":"address"},{"internalType":"uint256","name":"_tokenAmount","type":"uint256"}],"name":"recoverWrongTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stakedToken","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"startBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"stopReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapContract","outputs":[{"internalType":"contract ISwapContractMin","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_bonusEndBlock","type":"uint256"}],"name":"updateEndBlocks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_rewardPerBlock","type":"uint256"},{"internalType":"uint256","name":"_maxRewardPerBlock","type":"uint256"},{"internalType":"bool","name":"_isDynamic","type":"bool"}],"name":"updateRewardPerBlock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_startBlock","type":"uint256"},{"internalType":"uint256","name":"_bonusEndBlock","type":"uint256"}],"name":"updateStartAndEndBlocks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000044a62c7121a64691b61aef669f21c628258e7d520000000000000000000000008287c7b963b405b7b8d467db9d79eec40625b13a0000000000000000000000004a084c0d1f89793bb57f49b97c4e3a24ca539aaa0000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c5990000000000000000000000000000000000000000000000000de0b6b3a7640000000000000000000000000000000000000000000000000000136dcc951d8c00000000000000000000000000000000000000000000000000000000000000deffe100000000000000000000000000000000000000000000000000000000016058f5

-----Decoded View---------------
Arg [0] : _stakedToken (address): 0x44a62c7121A64691b61aef669f21c628258e7d52
Arg [1] : _rewardToken (address): 0x8287C7b963b405b7B8D467DB9d79eEC40625b13A
Arg [2] : _swapContract (address): 0x4A084C0D1f89793Bb57f49b97c4e3a24cA539aAA
Arg [3] : _btct (address): 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599
Arg [4] : _rewardPerBlock (uint256): 1000000000000000000
Arg [5] : _maxRewardPerBlock (uint256): 1400000000000000000
Arg [6] : _startBlock (uint256): 14614497
Arg [7] : _bonusEndBlock (uint256): 23091445

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 00000000000000000000000044a62c7121a64691b61aef669f21c628258e7d52
Arg [1] : 0000000000000000000000008287c7b963b405b7b8d467db9d79eec40625b13a
Arg [2] : 0000000000000000000000004a084c0d1f89793bb57f49b97c4e3a24ca539aaa
Arg [3] : 0000000000000000000000002260fac5e5542a773aa44fbcfedf7c193bc2c599
Arg [4] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [5] : 000000000000000000000000000000000000000000000000136dcc951d8c0000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000deffe1
Arg [7] : 00000000000000000000000000000000000000000000000000000000016058f5

39930:15338:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40785:36;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40302:34;;;:::i;:::-;;;;;;;:::i;47109:662::-;;;;;;:::i;:::-;;:::i;:::-;;41368:44;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;40467:28::-;;;:::i;44122:781::-;;;;;;:::i;:::-;;:::i;51207:1866::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;:::i;45630:190::-;;;;;;:::i;:::-;;:::i;41203:25::-;;;:::i;46110:510::-;;;;;;:::i;:::-;;:::i;40557:25::-;;;:::i;40967:28::-;;;:::i;:::-;;;;;;;:::i;36283:94::-;;;:::i;46711:88::-;;;:::i;41275:26::-;;;:::i;40702:29::-;;;:::i;41110:25::-;;;:::i;35632:87::-;;;:::i;40087:46::-;;;:::i;40376:31::-;;;:::i;48015:705::-;;;;;;:::i;:::-;;:::i;40639:30::-;;;:::i;43117:854::-;;;;;;:::i;:::-;;:::i;40234:35::-;;;:::i;45045:466::-;;;:::i;36532:192::-;;;;;;:::i;:::-;;:::i;49304:864::-;;;;;;:::i;:::-;;:::i;41040:24::-;;;:::i;40166:35::-;;;:::i;48871:259::-;;;;;;:::i;:::-;;:::i;40872:32::-;;;:::i;40785:36::-;;;;:::o;40302:34::-;;;:::o;47109:662::-;35863:12;:10;:12::i;:::-;-1:-1:-1;;;;;35852:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;35852:23:0;;35844:68;;;;-1:-1:-1;;;35844:68:0;;;;;;;:::i;:::-;;;;;;;;;47300:4:::1;47281:15;:23;;47273:32;;;::::0;::::1;;47343:4;47324:15;:23;;47316:32;;;::::0;::::1;;47389:15;47367:18;:37;;47359:46;;;::::0;::::1;;47416:13;:11;:13::i;:::-;47440:14;:32:::0;;;47483:21:::1;:38:::0;;;47532:17:::1;:38:::0;;;47581:9:::1;:22:::0;;-1:-1:-1;;47581:22:0::1;::::0;::::1;;;::::0;;;47614:100:::1;;47646:12;:20:::0;;-1:-1:-1;;47681:21:0;;;47614:100:::1;47729:34;47747:15;47729:34;;;;;;:::i;:::-;;;;;;;;47109:662:::0;;;:::o;41368:44::-;;;;;;;;;;;;;;;;;;;:::o;40467:28::-;;;;:::o;44122:781::-;38563:1;39168:7;;:19;;39160:63;;;;-1:-1:-1;;;39160:63:0;;;;;;;:::i;:::-;38563:1;39301:7;:18;44223:10:::1;44190:21;44214:20:::0;;;:8:::1;:20;::::0;;;;44253:11;;:22;-1:-1:-1;44253:22:0::1;44245:62;;;;-1:-1:-1::0;;;44245:62:0::1;;;;;;;:::i;:::-;44320:13;:11;:13::i;:::-;44346:15;44364:88;44426:4;:15;;;44364:43;44402:4;44364:33;44380:16;;44364:4;:11;;;:15;;:33;;;;:::i;:::-;:37:::0;::::1;:43::i;:::-;:47:::0;::::1;:88::i;:::-;44346:106:::0;-1:-1:-1;44469:12:0;;44465:152:::1;;44512:11:::0;;:24:::1;::::0;44528:7;44512:15:::1;:24::i;:::-;44498:38:::0;;44551:54:::1;-1:-1:-1::0;;;;;44551:11:0::1;:24;44584:10;44597:7:::0;44551:24:::1;:54::i;:::-;44633:12:::0;;44629:99:::1;;44662:54;-1:-1:-1::0;;;;;44662:11:0::1;:24;44695:10;44708:7:::0;44662:24:::1;:54::i;:::-;44774:16;::::0;44758:11;;:43:::1;::::0;44796:4:::1;::::0;44758:33:::1;::::0;:15:::1;:33::i;:43::-;44740:15;::::0;::::1;:61:::0;44826:11:::1;::::0;:24:::1;::::0;44842:7;44826:15:::1;:24::i;:::-;44812:11;:38:::0;44866:29:::1;::::0;44875:10:::1;::::0;44866:29:::1;::::0;::::1;::::0;44887:7;;44866:29:::1;:::i;:::-;;;;;;;;-1:-1:-1::0;;38519:1:0;39480:22;;-1:-1:-1;44122:781:0:o;51207:1866::-;51344:22;51381:18;51414:19;51448:12;51488:14;51520:15;;51505:12;:30;;;;:::i;:::-;:101;;51605:1;51505:101;;;51573:15;;51556:33;;:12;;:16;:33::i;:::-;51488:118;;51632:2;51623:6;:11;51619:28;;;-1:-1:-1;51645:2:0;51619:28;51677:14;;51730:88;;-1:-1:-1;;;51730:88:0;;51677:14;;-1:-1:-1;;;;;;51730:12:0;:28;;;;:88;;51781:1;;51798:9;;51730:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;51702:116;;-1:-1:-1;51702:116:0;-1:-1:-1;;;;;;51839:22:0;;;;:45;;;51875:9;-1:-1:-1;;;;;51865:19:0;:6;-1:-1:-1;;;;;51865:19:0;;51839:45;51831:54;;;;;;-1:-1:-1;;;;;51902:22:0;;51898:132;;51939:30;:10;51954:14;51939;:30::i;:::-;51926:43;;51898:132;;;51999:31;:11;52015:14;51999:15;:31::i;:::-;51985:45;;51898:132;52065:11;52051:10;:25;;52050:113;;52136:27;:11;52152:10;52136:15;:27::i;:::-;52050:113;;;52093:27;:10;52108:11;52093:14;:27::i;:::-;52181:12;;52043:120;;-1:-1:-1;52181:12:0;;;;;;:29;;-1:-1:-1;52197:13:0;;;;;;;52181:29;52180:44;;;;-1:-1:-1;52215:9:0;;;;52180:44;52176:591;;;52256:4;52243:10;;:17;52239:528;;;52298:102;52339:42;52374:6;52339:30;52364:4;52339:20;52354:4;52339:10;;:14;;:20;;;;:::i;:::-;:24;;:30::i;:42::-;52298:14;;;:18;:102::i;:::-;52281:119;;52239:528;;;52502:14;;52468:30;52493:4;52468:20;52477:10;;52468:4;:8;;:20;;;;:::i;:30::-;:48;52464:287;;52556:110;52601:42;52636:6;52601:30;52626:4;52601:20;52610:10;;52601:4;:8;;:20;;;;:::i;:42::-;52556:14;;;:18;:110::i;52464:287::-;52730:21;;52713:38;;52464:287;52801:17;;52783:14;:35;52779:102;;52852:17;;52835:34;;52779:102;52913:21;;52895:14;:39;52891:110;;52968:21;;52951:38;;52891:110;53011:54;51207:1866;;;;;;;:::o;45630:190::-;35863:12;:10;:12::i;:::-;-1:-1:-1;;;;;35852:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;35852:23:0;;35844:68;;;;-1:-1:-1;;;35844:68:0;;;;;;;:::i;:::-;45710:54:::1;-1:-1:-1::0;;;;;45710:11:0::1;:24;45743:10;45756:7:::0;45710:24:::1;:54::i;:::-;45780:32;45804:7;45780:32;;;;;;:::i;:::-;;;;;;;;45630:190:::0;:::o;41203:25::-;;;;:::o;46110:510::-;35863:12;:10;:12::i;:::-;-1:-1:-1;;;;;35852:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;35852:23:0;;35844:68;;;;-1:-1:-1;;;35844:68:0;;;;;;;:::i;:::-;46283:11:::1;-1:-1:-1::0;;;;;46258:37:0::1;:13;-1:-1:-1::0;;;;;46258:37:0::1;;;46236:109;;;;-1:-1:-1::0;;;46236:109:0::1;;;;;;;:::i;:::-;46403:11;-1:-1:-1::0;;;;;46378:37:0::1;:13;-1:-1:-1::0;;;;;46378:37:0::1;;;46356:109;;;;-1:-1:-1::0;;;46356:109:0::1;;;;;;;:::i;:::-;46478:69;-1:-1:-1::0;;;;;46478:34:0;::::1;46521:10;46534:12:::0;46478:34:::1;:69::i;:::-;46565:47;46584:13;46599:12;46565:47;;;;;;;:::i;:::-;;;;;;;;46110:510:::0;;:::o;40557:25::-;;;;:::o;40967:28::-;;;;;;:::o;36283:94::-;35863:12;:10;:12::i;:::-;-1:-1:-1;;;;;35852:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;35852:23:0;;35844:68;;;;-1:-1:-1;;;35844:68:0;;;;;;;:::i;:::-;36348:21:::1;36366:1;36348:9;:21::i;:::-;36283:94::o:0;46711:88::-;35863:12;:10;:12::i;:::-;-1:-1:-1;;;;;35852:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;35852:23:0;;35844:68;;;;-1:-1:-1;;;35844:68:0;;;;;;;:::i;:::-;46779:12:::1;46763:13;:28:::0;46711:88::o;41275:26::-;;;;:::o;40702:29::-;;;;:::o;41110:25::-;;;;;;;;;:::o;35632:87::-;35678:7;35705:6;-1:-1:-1;;;;;35705:6:0;35632:87;:::o;40087:46::-;;;:::o;40376:31::-;;;;:::o;48015:705::-;35863:12;:10;:12::i;:::-;-1:-1:-1;;;;;35852:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;35852:23:0;;35844:68;;;;-1:-1:-1;;;35844:68:0;;;;;;;:::i;:::-;48171:10:::1;;48156:12;:25;48148:54;;;;-1:-1:-1::0;;;48148:54:0::1;;;;;;;:::i;:::-;48249:14;48235:11;:28;48213:124;;;;-1:-1:-1::0;;;48213:124:0::1;;;;;;;:::i;:::-;48385:11;48370:12;:26;48348:124;;;;-1:-1:-1::0;;;48348:124:0::1;;;;;;;:::i;:::-;48485:10;:24:::0;;;48520:13:::1;:30:::0;;;48617:15:::1;:28:::0;;;48663:49:::1;::::0;::::1;::::0;::::1;::::0;48498:11;;48536:14;;48663:49:::1;:::i;40639:30::-:0;;;;:::o;43117:854::-;38563:1;39168:7;;:19;;39160:63;;;;-1:-1:-1;;;39160:63:0;;;;;;;:::i;:::-;38563:1;39301:7;:18;43217:10:::1;43184:21;43208:20:::0;;;:8:::1;:20;::::0;;;;43239:13:::1;:11;:13::i;:::-;43269:11:::0;;:16;43265:283:::1;;43302:15;43320:96;43386:4;:15;;;43320:43;43358:4;43320:33;43336:16;;43320:4;:11;;;:15;;:33;;;;:::i;:96::-;43302:114:::0;-1:-1:-1;43435:11:0;;43431:106:::1;;43467:54;-1:-1:-1::0;;;;;43467:11:0::1;:24;43500:10;43513:7:::0;43467:24:::1;:54::i;:::-;43265:283;;43564:12:::0;;43560:237:::1;;43607:11:::0;;:24:::1;::::0;43623:7;43607:15:::1;:24::i;:::-;43593:38:::0;;43646:139:::1;-1:-1:-1::0;;;;;43646:11:0::1;:28;43701:10;43739:4;43763:7:::0;43646:28:::1;:139::i;:::-;43843:16;::::0;43827:11;;:43:::1;::::0;43865:4:::1;::::0;43827:33:::1;::::0;:15:::1;:33::i;:43::-;43809:15;::::0;::::1;:61:::0;43895:11:::1;::::0;:24:::1;::::0;43911:7;43895:15:::1;:24::i;:::-;43881:11;:38:::0;43935:28:::1;::::0;43943:10:::1;::::0;43935:28:::1;::::0;::::1;::::0;43955:7;;43935:28:::1;:::i;:::-;;;;;;;;-1:-1:-1::0;;38519:1:0;39480:22;;43117:854::o;40234:35::-;;;:::o;45045:466::-;38563:1;39168:7;;:19;;39160:63;;;;-1:-1:-1;;;39160:63:0;;;;;;;:::i;:::-;38563:1;39301:7;:18;;;45140:10:::1;45107:21;45131:20:::0;;;:8:::1;:20;::::0;;;;45189:11;;45211:15;;;45237;;::::1;:19:::0;;;;45131:20;45273:21;;45269:117:::1;;45311:63;-1:-1:-1::0;;;;;45311:11:0::1;:24;45344:10;45357:16:::0;45311:24:::1;:63::i;:::-;45410:11;::::0;:33:::1;::::0;45426:16;45410:15:::1;:33::i;:::-;45396:11;:47:::0;45491:11;;45461:42:::1;::::0;45479:10:::1;::::0;45461:42:::1;::::0;::::1;::::0;45491:11;45461:42:::1;:::i;36532:192::-:0;35863:12;:10;:12::i;:::-;-1:-1:-1;;;;;35852:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;35852:23:0;;35844:68;;;;-1:-1:-1;;;35844:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;36621:22:0;::::1;36613:73;;;;-1:-1:-1::0;;;36613:73:0::1;;;;;;;:::i;:::-;36697:19;36707:8;36697:9;:19::i;:::-;36532:192:::0;:::o;49304:864::-;-1:-1:-1;;;;;49409:15:0;;49365:7;49409:15;;;:8;:15;;;;;49463:11;;49504:15;;49489:12;:30;:56;;;;-1:-1:-1;49523:22:0;;;49489:56;49485:676;;;49562:18;49583:45;49598:15;;49615:12;49583:14;:45::i;:::-;49562:66;;49643:19;49665:30;49680:14;;49665:10;:14;;:30;;;;:::i;:::-;49643:52;-1:-1:-1;49710:29:0;49742:98;49781:44;49807:17;49781:21;49643:52;49797:4;49781:15;:21::i;:44::-;49742:16;;;:20;:98::i;:::-;49710:130;;49879:109;49954:4;:15;;;49879:48;49922:4;49879:38;49895:21;49879:4;:11;;;:15;;:38;;;;:::i;:109::-;49855:133;;;;;;;;;49485:676;50045:104;50115:4;:15;;;50045:43;50083:4;50045:33;50061:16;;50045:4;:11;;;:15;;:33;;;;:::i;:104::-;50021:128;;;;49304:864;;;;:::o;41040:24::-;;;;;;;;;:::o;40166:35::-;;;:::o;48871:259::-;35863:12;:10;:12::i;:::-;-1:-1:-1;;;;;35852:23:0;:7;:5;:7::i;:::-;-1:-1:-1;;;;;35852:23:0;;35844:68;;;;-1:-1:-1;;;35844:68:0;;;;;;;:::i;:::-;48987:14:::1;48972:12;:29;48950:131;;;;-1:-1:-1::0;;;48950:131:0::1;;;;;;;:::i;:::-;49092:13;:30:::0;48871:259::o;40872:32::-;;;;:::o;34498:98::-;34578:10;34498:98;:::o;50270:663::-;50333:15;;50317:12;:31;50313:70;;50365:7;;50313:70;50421:36;;-1:-1:-1;;;50421:36:0;;50393:25;;-1:-1:-1;;;;;50421:11:0;:21;;;;:36;;50451:4;;50421:36;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50393:64;-1:-1:-1;50474:22:0;50470:106;;-1:-1:-1;50531:12:0;50513:15;:30;50558:7;;50470:106;50586:18;50607:45;50622:15;;50639:12;50607:14;:45::i;:::-;50586:66;;50663:19;50685:30;50700:14;;50685:10;:14;;:30;;;;:::i;:::-;50663:52;-1:-1:-1;50745:90:0;50780:44;50806:17;50780:21;50663:52;50796:4;50780:15;:21::i;50745:90::-;50726:16;:109;50850:9;;;;50846:38;;;50861:23;:21;:23::i;:::-;-1:-1:-1;;50913:12:0;50895:15;:30;-1:-1:-1;50270:663:0:o;30525:98::-;30583:7;30610:5;30614:1;30610;:5;:::i;:::-;30603:12;;30525:98;;;;;:::o;30924:::-;30982:7;31009:5;31013:1;31009;:5;:::i;30168:98::-;30226:7;30253:5;30257:1;30253;:5;:::i;11368:211::-;11485:86;11505:5;11535:23;;;11560:2;11564:5;11512:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;11512:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;11512:58:0;-1:-1:-1;;;;;;11512:58:0;;;;;;;;;;11485:19;:86::i;:::-;11368:211;;;:::o;29787:98::-;29845:7;29872:5;29876:1;29872;:5;:::i;36732:173::-;36788:16;36807:6;;-1:-1:-1;;;;;36824:17:0;;;-1:-1:-1;;;;;;36824:17:0;;;;;;36857:40;;36807:6;;;;;;;36857:40;;36788:16;36857:40;36732:173;;:::o;11587:248::-;11731:96;11751:5;11781:27;;;11810:4;11816:2;11820:5;11758:68;;;;;;;;;;:::i;11731:96::-;11587:248;;;;:::o;54924:341::-;55026:7;55062:13;;55055:3;:20;55051:207;;55099:14;:3;55107:5;55099:7;:14::i;:::-;55092:21;;;;55051:207;55144:13;;55135:5;:22;55131:127;;-1:-1:-1;55181:1:0;55174:8;;55131:127;55222:13;;:24;;55240:5;55222:17;:24::i;53137:1612::-;53205:22;53242:18;53275:19;53309:12;53335:42;53369:3;53375:1;53335:25;:42::i;:::-;53190:187;;;;;;;;53437:14;53420;:31;;;;53562:11;53548:10;:25;;:41;;;;-1:-1:-1;53577:12:0;;;;;;;53548:41;53544:202;;;53661:12;:20;;-1:-1:-1;;53661:20:0;;;53713:21;;53696:14;:38;53544:202;53859:10;53844:11;:25;;:42;;;;-1:-1:-1;53873:13:0;;;;;;;53844:42;53840:205;;;53959:13;:21;;-1:-1:-1;;53959:21:0;;;54012;;53995:14;:38;53840:205;54165:84;;-1:-1:-1;;;54165:84:0;;54137:25;;-1:-1:-1;;;;;54165:12:0;:30;;;;:84;;54137:25;;;;54165:84;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54137:112;;54260:26;54289:12;-1:-1:-1;;;;;54289:30:0;;54334:9;54358:1;54289:81;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54260:110;-1:-1:-1;54473:22:0;;54469:75;;54512:13;:20;;-1:-1:-1;;54512:20:0;;;;;54469:75;54643:23;;54639:75;;54683:12;:19;;-1:-1:-1;;54683:19:0;;;;;54639:75;-1:-1:-1;;54724:10:0;:17;-1:-1:-1;;;53137:1612:0:o;13941:716::-;14365:23;14391:69;14419:4;14391:69;;;;;;;;;;;;;;;;;14399:5;-1:-1:-1;;;;;14391:27:0;;;:69;;;;;:::i;:::-;14475:17;;14365:95;;-1:-1:-1;14475:21:0;14471:179;;14572:10;14561:30;;;;;;;;;;;;:::i;:::-;14553:85;;;;-1:-1:-1;;;14553:85:0;;;;;;;:::i;6305:229::-;6442:12;6474:52;6496:6;6504:4;6510:1;6513:12;6474:21;:52::i;:::-;6467:59;;6305:229;;;;;;:::o;7425:510::-;7595:12;7653:5;7628:21;:30;;7620:81;;;;-1:-1:-1;;;7620:81:0;;;;;;;:::i;:::-;7720:18;7731:6;7720:10;:18::i;:::-;7712:60;;;;-1:-1:-1;;;7712:60:0;;;;;;;:::i;:::-;7786:12;7800:23;7827:6;-1:-1:-1;;;;;7827:11:0;7846:5;7853:4;7827:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7785:73;;;;7876:51;7893:7;7902:10;7914:12;7876:16;:51::i;:::-;7869:58;7425:510;-1:-1:-1;;;;;;;7425:510:0:o;3499:387::-;3822:20;3870:8;;;3499:387::o;10111:712::-;10261:12;10290:7;10286:530;;;-1:-1:-1;10321:10:0;10314:17;;10286:530;10435:17;;:21;10431:374;;10633:10;10627:17;10694:15;10681:10;10677:2;10673:19;10666:44;10581:148;10776:12;10769:20;;-1:-1:-1;;;10769:20:0;;;;;;;;:::i;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:266::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;653:2;638:18;;;;625:32;;-1:-1:-1;;;484:179:1:o;668:257::-;;788:2;776:9;767:7;763:23;759:32;756:2;;;809:6;801;794:22;756:2;846:9;840:16;865:30;889:5;865:30;:::i;930:190::-;;1042:2;1030:9;1021:7;1017:23;1013:32;1010:2;;;1063:6;1055;1048:22;1010:2;-1:-1:-1;1091:23:1;;1000:120;-1:-1:-1;1000:120:1:o;1125:194::-;;1248:2;1236:9;1227:7;1223:23;1219:32;1216:2;;;1269:6;1261;1254:22;1216:2;-1:-1:-1;1297:16:1;;1206:113;-1:-1:-1;1206:113:1:o;1324:258::-;;;1453:2;1441:9;1432:7;1428:23;1424:32;1421:2;;;1474:6;1466;1459:22;1421:2;-1:-1:-1;;1502:23:1;;;1572:2;1557:18;;;1544:32;;-1:-1:-1;1411:171:1:o;1587:255::-;;;1727:2;1715:9;1706:7;1702:23;1698:32;1695:2;;;1748:6;1740;1733:22;1695:2;-1:-1:-1;;1776:16:1;;1832:2;1817:18;;;1811:25;1776:16;;1811:25;;-1:-1:-1;1685:157:1:o;1847:389::-;;;;1990:2;1978:9;1969:7;1965:23;1961:32;1958:2;;;2011:6;2003;1996:22;1958:2;2052:9;2039:23;2029:33;;2109:2;2098:9;2094:18;2081:32;2071:42;;2163:2;2152:9;2148:18;2135:32;2176:30;2200:5;2176:30;:::i;:::-;2225:5;2215:15;;;1948:288;;;;;:::o;2241:274::-;;2408:6;2402:13;2424:53;2470:6;2465:3;2458:4;2450:6;2446:17;2424:53;:::i;:::-;2493:16;;;;;2378:137;-1:-1:-1;;2378:137:1:o;2520:203::-;-1:-1:-1;;;;;2684:32:1;;;;2666:51;;2654:2;2639:18;;2621:102::o;2728:304::-;-1:-1:-1;;;;;2958:15:1;;;2940:34;;3010:15;;3005:2;2990:18;;2983:43;2890:2;2875:18;;2857:175::o;3037:375::-;-1:-1:-1;;;;;3295:15:1;;;3277:34;;3347:15;;;;3342:2;3327:18;;3320:43;3394:2;3379:18;;3372:34;;;;3227:2;3212:18;;3194:218::o;3417:282::-;-1:-1:-1;;;;;3617:32:1;;;;3599:51;;3681:2;3666:18;;3659:34;3587:2;3572:18;;3554:145::o;3983:187::-;4148:14;;4141:22;4123:41;;4111:2;4096:18;;4078:92::o;4629:383::-;;4778:2;4767:9;4760:21;4810:6;4804:13;4853:6;4848:2;4837:9;4833:18;4826:34;4869:66;4928:6;4923:2;4912:9;4908:18;4903:2;4895:6;4891:15;4869:66;:::i;:::-;4996:2;4975:15;-1:-1:-1;;4971:29:1;4956:45;;;;5003:2;4952:54;;4750:262;-1:-1:-1;;4750:262:1:o;5017:402::-;5219:2;5201:21;;;5258:2;5238:18;;;5231:30;5297:34;5292:2;5277:18;;5270:62;-1:-1:-1;;;5363:2:1;5348:18;;5341:36;5409:3;5394:19;;5191:228::o;5424:340::-;5626:2;5608:21;;;5665:2;5645:18;;;5638:30;-1:-1:-1;;;5699:2:1;5684:18;;5677:46;5755:2;5740:18;;5598:166::o;5769:410::-;5971:2;5953:21;;;6010:2;5990:18;;;5983:30;6049:34;6044:2;6029:18;;6022:62;-1:-1:-1;;;6115:2:1;6100:18;;6093:44;6169:3;6154:19;;5943:236::o;6184:402::-;6386:2;6368:21;;;6425:2;6405:18;;;6398:30;6464:34;6459:2;6444:18;;6437:62;-1:-1:-1;;;6530:2:1;6515:18;;6508:36;6576:3;6561:19;;6358:228::o;6591:412::-;6793:2;6775:21;;;6832:2;6812:18;;;6805:30;6871:34;6866:2;6851:18;;6844:62;-1:-1:-1;;;6937:2:1;6922:18;;6915:46;6993:3;6978:19;;6765:238::o;7008:356::-;7210:2;7192:21;;;7229:18;;;7222:30;7288:34;7283:2;7268:18;;7261:62;7355:2;7340:18;;7182:182::o;7369:346::-;7571:2;7553:21;;;7610:2;7590:18;;;7583:30;-1:-1:-1;;;7644:2:1;7629:18;;7622:52;7706:2;7691:18;;7543:172::o;7720:351::-;7922:2;7904:21;;;7961:2;7941:18;;;7934:30;8000:29;7995:2;7980:18;;7973:57;8062:2;8047:18;;7894:177::o;8076:416::-;8278:2;8260:21;;;8317:2;8297:18;;;8290:30;8356:34;8351:2;8336:18;;8329:62;-1:-1:-1;;;8422:2:1;8407:18;;8400:50;8482:3;8467:19;;8250:242::o;8497:353::-;8699:2;8681:21;;;8738:2;8718:18;;;8711:30;8777:31;8772:2;8757:18;;8750:59;8841:2;8826:18;;8671:179::o;8855:346::-;9057:2;9039:21;;;9096:2;9076:18;;;9069:30;-1:-1:-1;;;9130:2:1;9115:18;;9108:52;9192:2;9177:18;;9029:172::o;9206:406::-;9408:2;9390:21;;;9447:2;9427:18;;;9420:30;9486:34;9481:2;9466:18;;9459:62;-1:-1:-1;;;9552:2:1;9537:18;;9530:40;9602:3;9587:19;;9380:232::o;9617:355::-;9819:2;9801:21;;;9858:2;9838:18;;;9831:30;9897:33;9892:2;9877:18;;9870:61;9963:2;9948:18;;9791:181::o;9977:177::-;10123:25;;;10111:2;10096:18;;10078:76::o;10159:248::-;10333:25;;;10389:2;10374:18;;10367:34;10321:2;10306:18;;10288:119::o;10412:391::-;10643:25;;;10699:2;10684:18;;10677:34;;;;10742:2;10727:18;;10720:34;10785:2;10770:18;;10763:34;10630:3;10615:19;;10597:206::o;10808:128::-;;10879:1;10875:6;10872:1;10869:13;10866:2;;;10885:18;;:::i;:::-;-1:-1:-1;10921:9:1;;10856:80::o;10941:217::-;;11007:1;10997:2;;-1:-1:-1;;;11032:31:1;;11086:4;11083:1;11076:15;11114:4;11039:1;11104:15;10997:2;-1:-1:-1;11143:9:1;;10987:171::o;11163:168::-;;11269:1;11265;11261:6;11257:14;11254:1;11251:21;11246:1;11239:9;11232:17;11228:45;11225:2;;;11276:18;;:::i;:::-;-1:-1:-1;11316:9:1;;11215:116::o;11336:125::-;;11404:1;11401;11398:8;11395:2;;;11409:18;;:::i;:::-;-1:-1:-1;11446:9:1;;11385:76::o;11466:258::-;11538:1;11548:113;11562:6;11559:1;11556:13;11548:113;;;11638:11;;;11632:18;11619:11;;;11612:39;11584:2;11577:10;11548:113;;;11679:6;11676:1;11673:13;11670:2;;;-1:-1:-1;;11714:1:1;11696:16;;11689:27;11519:205::o;11729:127::-;11790:10;11785:3;11781:20;11778:1;11771:31;11821:4;11818:1;11811:15;11845:4;11842:1;11835:15;11861:120;11949:5;11942:13;11935:21;11928:5;11925:32;11915:2;;11971:1;11968;11961:12

ipfs://7696200818a59a4b8e6dbc1a68001b5a9bef8cedd5d4f1b3e491632ca27f1878