Contract 0x37dcb419be789d94b3216b922c216f5fa3266cfe

/**
 *Submitted for verification at FtmScan.com on 2021-12-05
*/

/**
 *Submitted for verification at Etherscan.io on 2021-05-31
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

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

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        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");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (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");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private 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

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

/**
 * @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 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.
 */
contract OwnableData {
    address public owner;
    address public pendingOwner;
}

abstract contract Ownable is OwnableData {
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    constructor () {
        owner = msg.sender;
        emit OwnershipTransferred(address(0), msg.sender);
    }

    function transferOwnership(address newOwner, bool direct, bool renounce) public onlyOwner {
        if (direct) {

            require(newOwner != address(0) || renounce, "Ownable: zero address");

            emit OwnershipTransferred(owner, newOwner);
            owner = newOwner;
        } else {
            pendingOwner = newOwner;
        }
    }

    function claimOwnership() public {
        address _pendingOwner = pendingOwner;

        require(msg.sender == _pendingOwner, "Ownable: caller != pending owner");

        emit OwnershipTransferred(owner, _pendingOwner);
        owner = _pendingOwner;
        pendingOwner = address(0);
    }

    modifier onlyOwner() {
        require(msg.sender == owner, "Ownable: caller is not the owner");
        _;
    }
}

/**
 * @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'
        // solhint-disable-next-line max-line-length
        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
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}
// Sorbettiere is a "semifredo of popsicle stand" this contract is created to provide single side farm for IFO of Popsicle Finance.
// The contract is based on famous Masterchef contract (Ty guys for that)
// It intakes one token and allows the user to farm another token. Due to the crosschain nature of Popsicle Stand we've swapped reward per block
// to reward per second. Moreover, we've implemented safe transfer of reward instead of mint in Masterchef.
// Future is crosschain...

// The contract is ownable untill the DAO will be able to take over. Popsicle community shows that DAO is coming soon.
// And the contract ownership will be transferred to other contract
contract Sorbettiere is Ownable {
    using SafeERC20 for IERC20;
    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many LP tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
        uint256 remainingIceTokenReward;  // ICE Tokens that weren't distributed for user per pool.
        //
        // We do some fancy math here. Basically, any point in time, the amount of ICE
        // entitled to a user but is pending to be distributed is:
        //
        //   pending reward = (user.amount * pool.accICEPerShare) - user.rewardDebt
        //
        // Whenever a user deposits or withdraws Staked tokens to a pool. Here's what happens:
        //   1. The pool's `accICEPerShare` (and `lastRewardTime`) gets updated.
        //   2. User receives the pending reward sent to his/her address.
        //   3. User's `amount` gets updated.
        //   4. User's `rewardDebt` gets updated.
    }
    // Info of each pool.
    struct PoolInfo {
        IERC20 stakingToken; // Contract address of staked token
        uint256 stakingTokenTotalAmount; //Total amount of deposited tokens
        uint256 accIcePerShare; // Accumulated ICE per share, times 1e12. See below.
        uint32 lastRewardTime; // Last timestamp number that ICE distribution occurs.
        uint16 allocPoint; // How many allocation points assigned to this pool. ICE to distribute per second.
        
        
    }
    
    IERC20 immutable public ice; // The ICE TOKEN!!
    
    uint256 public icePerSecond; // Ice tokens vested per second.
    
    PoolInfo[] public poolInfo; // Info of each pool.
    
    mapping(uint256 => mapping(address => UserInfo)) public userInfo; // Info of each user that stakes tokens.
    
    uint256 public totalAllocPoint = 0; // Total allocation poitns. Must be the sum of all allocation points in all pools.
    
    uint32 immutable public startTime; // The timestamp when ICE farming starts.
    
    uint32 public endTime; // Time on which the reward calculation should end

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);

    constructor(
        IERC20 _ice,
        uint256 _icePerSecond,
        uint32 _startTime
    ) {
        ice = _ice;
        
        icePerSecond = _icePerSecond;
        startTime = _startTime;
        endTime = _startTime + 7 days;
    }
    
    function changeEndTime(uint32 addSeconds) external onlyOwner {
        endTime += addSeconds;
    }
    
    // Changes Ice token reward per second. Use this function to moderate the `lockup amount`. Essentially this function changes the amount of the reward
    // which is entitled to the user for his token staking by the time the `endTime` is passed.
    //Good practice to update pools without messing up the contract
    function setIcePerSecond(uint256 _icePerSecond,  bool _withUpdate) external onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        icePerSecond= _icePerSecond;
    }
// How many pools are in the contract
    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    // Add a new staking token to the pool. Can only be called by the owner.
    // VERY IMPORTANT NOTICE 
    // ----------- DO NOT add the same staking token more than once. Rewards will be messed up if you do. -------------
    // Good practice to update pools without messing up the contract
    function add(
        uint16 _allocPoint,
        IERC20 _stakingToken,
        bool _withUpdate
    ) external onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        uint256 lastRewardTime =
            block.timestamp > startTime ? block.timestamp : startTime;
        totalAllocPoint +=_allocPoint;
        poolInfo.push(
            PoolInfo({
                stakingToken: _stakingToken,
                stakingTokenTotalAmount: 0,
                allocPoint: _allocPoint,
                lastRewardTime: uint32(lastRewardTime),
                accIcePerShare: 0
            })
        );
    }

    // Update the given pool's ICE allocation point. Can only be called by the owner.
    // Good practice to update pools without messing up the contract
    function set(
        uint256 _pid,
        uint16 _allocPoint,
        bool _withUpdate
    ) external onlyOwner {
        if (_withUpdate) {
            massUpdatePools();
        }
        totalAllocPoint = totalAllocPoint - poolInfo[_pid].allocPoint + _allocPoint;
        poolInfo[_pid].allocPoint = _allocPoint;
    }

    // Return reward multiplier over the given _from to _to time.
    function getMultiplier(uint256 _from, uint256 _to)
        public
        view
        returns (uint256)
    {
        _from = _from > startTime ? _from : startTime;
        if (_from > endTime || _to < startTime) {
            return 0;
        }
        if (_to > endTime) {
            return endTime - _from;
        }
        return _to - _from;
    }

    // View function to see pending ICE on frontend.
    function pendingIce(uint256 _pid, address _user)
        external
        view
        returns (uint256)
    {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accIcePerShare = pool.accIcePerShare;
       
        if (block.timestamp > pool.lastRewardTime && pool.stakingTokenTotalAmount != 0) {
            uint256 multiplier =
                getMultiplier(pool.lastRewardTime, block.timestamp);
            uint256 iceReward =
                multiplier * icePerSecond * pool.allocPoint / totalAllocPoint;
            accIcePerShare += iceReward * 1e12 / pool.stakingTokenTotalAmount;
        }
        return user.amount * accIcePerShare / 1e12 - user.rewardDebt + user.remainingIceTokenReward;
    }

    // Update reward vairables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }

        if (pool.stakingTokenTotalAmount == 0) {
            pool.lastRewardTime = uint32(block.timestamp);
            return;
        }
        uint256 multiplier = getMultiplier(pool.lastRewardTime, block.timestamp);
        uint256 iceReward =
            multiplier * icePerSecond * pool.allocPoint / totalAllocPoint;
        pool.accIcePerShare += iceReward * 1e12 / pool.stakingTokenTotalAmount;
        pool.lastRewardTime = uint32(block.timestamp);
    }

    // Deposit staking tokens to Sorbettiere for ICE allocation.
    function deposit(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        updatePool(_pid);
        if (user.amount > 0) {
            uint256 pending =
                user.amount * pool.accIcePerShare / 1e12 - user.rewardDebt + user.remainingIceTokenReward;
            user.remainingIceTokenReward = safeRewardTransfer(msg.sender, pending);
        }
        pool.stakingToken.safeTransferFrom(
            address(msg.sender),
            address(this),
            _amount
        );
        user.amount += _amount;
        pool.stakingTokenTotalAmount += _amount;
        user.rewardDebt = user.amount * pool.accIcePerShare / 1e12;
        emit Deposit(msg.sender, _pid, _amount);
    }

    // Withdraw staked tokens from Sorbettiere.
    function withdraw(uint256 _pid, uint256 _amount) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        require(user.amount >= _amount, "Sorbettiere: you cant eat that much popsicles");
        updatePool(_pid);
        uint256 pending =
            user.amount * pool.accIcePerShare / 1e12 - user.rewardDebt + user.remainingIceTokenReward;
        user.remainingIceTokenReward = safeRewardTransfer(msg.sender, pending);
        user.amount -= _amount;
        pool.stakingTokenTotalAmount -= _amount;
        user.rewardDebt = user.amount * pool.accIcePerShare / 1e12;
        pool.stakingToken.safeTransfer(address(msg.sender), _amount);
        emit Withdraw(msg.sender, _pid, _amount);
    }
    
    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 userAmount = user.amount;
        pool.stakingTokenTotalAmount -= userAmount;
        delete userInfo[_pid][msg.sender];
        pool.stakingToken.safeTransfer(address(msg.sender), userAmount);
        emit EmergencyWithdraw(msg.sender, _pid, userAmount);
    }

    // Safe ice transfer function. Just in case if the pool does not have enough ICE token,
    // The function returns the amount which is owed to the user
    function safeRewardTransfer(address _to, uint256 _amount) internal returns(uint256) {
        uint256 iceTokenBalance = ice.balanceOf(address(this));
        if (iceTokenBalance == 0) { //save some gas fee
            return _amount;
        }
        if (_amount > iceTokenBalance) { //save some gas fee
            ice.safeTransfer(_to, iceTokenBalance);
            return _amount - iceTokenBalance;
        }
        ice.safeTransfer(_to, _amount);
        return 0;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"_ice","type":"address"},{"internalType":"uint256","name":"_icePerSecond","type":"uint256"},{"internalType":"uint32","name":"_startTime","type":"uint32"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"uint16","name":"_allocPoint","type":"uint16"},{"internalType":"contract IERC20","name":"_stakingToken","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"addSeconds","type":"uint32"}],"name":"changeEndTime","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"endTime","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_from","type":"uint256"},{"internalType":"uint256","name":"_to","type":"uint256"}],"name":"getMultiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ice","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"icePerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingIce","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"stakingToken","type":"address"},{"internalType":"uint256","name":"stakingTokenTotalAmount","type":"uint256"},{"internalType":"uint256","name":"accIcePerShare","type":"uint256"},{"internalType":"uint32","name":"lastRewardTime","type":"uint32"},{"internalType":"uint16","name":"allocPoint","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint16","name":"_allocPoint","type":"uint16"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_icePerSecond","type":"uint256"},{"internalType":"bool","name":"_withUpdate","type":"bool"}],"name":"setIcePerSecond","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startTime","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"},{"internalType":"bool","name":"direct","type":"bool"},{"internalType":"bool","name":"renounce","type":"bool"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"},{"internalType":"uint256","name":"remainingIceTokenReward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

000000000000000000000000248cb87dda803028dfead98101c9465a2fbda0d400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000061adfb40

-----Decoded View---------------
Arg [0] : _ice (address): 0x248cb87dda803028dfead98101c9465a2fbda0d4
Arg [1] : _icePerSecond (uint256): 0
Arg [2] : _startTime (uint32): 1638792000

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000248cb87dda803028dfead98101c9465a2fbda0d4
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [2] : 0000000000000000000000000000000000000000000000000000000061adfb40

16854:10048:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11643:363;;;;;;:::i;:::-;;:::i;:::-;;20166:95;20238:8;:15;20166:95;;;8559:25:1;;;8547:2;8532:18;20166:95:0;;;;;;;;18492:26;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;5116:32:1;;;5098:51;;5180:2;5165:18;;5158:34;;;;5208:18;;;5201:34;;;;5283:10;5271:23;5266:2;5251:18;;5244:51;5344:6;5332:19;5326:3;5311:19;;5304:48;5085:3;5070:19;18492:26:0;5052:306:1;18671:34:0;;;;;;18419:27;;;;;;18889:21;;;;;;;;;;;;9093:10:1;9081:23;;;9063:42;;9051:2;9036:18;18889:21:0;9018:93:1;24949:778:0;;;;;;:::i;:::-;;:::i;18360:27::-;;;;;;;;-1:-1:-1;;;;;3904:32:1;;;3886:51;;3874:2;3859:18;18360:27:0;3841:102:1;12014:301:0;;;:::i;23355:654::-;;;;;;:::i;:::-;;:::i;25802:443::-;;;;;;:::i;:::-;;:::i;23099:180::-;;;:::i;18801:33::-;;;;;11321:20;;;;;-1:-1:-1;;;;;11321:20:0;;;21794:369;;;;;;:::i;:::-;;:::i;18553:64::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8797:25:1;;;8853:2;8838:18;;8831:34;;;;8881:18;;;8874:34;8785:2;8770:18;18553:64:0;8752:162:1;20569:652:0;;;;;;:::i;:::-;;:::i;19484:101::-;;;;;;:::i;:::-;;:::i;21386:333::-;;;;;;:::i;:::-;;:::i;24083:809::-;;;;;;:::i;:::-;;:::i;11348:27::-;;;;;-1:-1:-1;;;;;11348:27:0;;;19918:203;;;;;;:::i;:::-;;:::i;22225:791::-;;;;;;:::i;:::-;;:::i;11643:363::-;12377:5;;-1:-1:-1;;;;;12377:5:0;12363:10;:19;12355:64;;;;-1:-1:-1;;;12355:64:0;;;;;;;:::i;:::-;;;;;;;;;11748:6:::1;11744:255;;;-1:-1:-1::0;;;;;11781:22:0;::::1;::::0;::::1;::::0;:34:::1;;;11807:8;11781:34;11773:68;;;::::0;-1:-1:-1;;;11773:68:0;;5953:2:1;11773:68:0::1;::::0;::::1;5935:21:1::0;5992:2;5972:18;;;5965:30;-1:-1:-1;;;6011:18:1;;;6004:51;6072:18;;11773:68:0::1;5925:171:1::0;11773:68:0::1;11884:5;::::0;;11863:37:::1;::::0;-1:-1:-1;;;;;11863:37:0;;::::1;::::0;11884:5;::::1;::::0;11863:37:::1;::::0;::::1;11915:5;:16:::0;;-1:-1:-1;;;;;11915:16:0;::::1;-1:-1:-1::0;;;;;;11915:16:0;;::::1;;::::0;;11643:363;;;:::o;11744:255::-:1;11964:12;:23:::0;;-1:-1:-1;;;;;;11964:23:0::1;-1:-1:-1::0;;;;;11964:23:0;::::1;;::::0;;11744:255:::1;11643:363:::0;;;:::o;18492:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18492:26:0;;;;-1:-1:-1;18492:26:0;;;;;;;;;;;;:::o;24949:778::-;25016:21;25040:8;25049:4;25040:14;;;;;;-1:-1:-1;;;25040:14:0;;;;;;;;;;;;;;;;;25089;;;25040;25089;;;;;;;25104:10;25089:26;;;;;;;;;25134:11;;25040:14;;;;;;;;-1:-1:-1;;;25134:22:0;25126:80;;;;-1:-1:-1;;;25126:80:0;;6710:2:1;25126:80:0;;;6692:21:1;6749:2;6729:18;;;6722:30;6788:34;6768:18;;;6761:62;-1:-1:-1;;;6839:18:1;;;6832:43;6892:19;;25126:80:0;6682:235:1;25126:80:0;25217:16;25228:4;25217:10;:16::i;:::-;25244:15;25336:4;:28;;;25318:4;:15;;;25311:4;25289;:19;;;25275:4;:11;;;:33;;;;:::i;:::-;:40;;;;:::i;:::-;:58;;;;:::i;:::-;:89;;;;:::i;:::-;25244:120;;25406:39;25425:10;25437:7;25406:18;:39::i;:::-;25375:28;;;:70;25456:22;;25471:7;;25375:4;;25456:11;;:22;;25471:7;;25456:22;:::i;:::-;;;;;;;;25521:7;25489:4;:28;;;:39;;;;;;;:::i;:::-;;;;-1:-1:-1;;25571:19:0;;;;25557:11;;25593:4;;25557:33;;;:::i;:::-;:40;;;;:::i;:::-;25539:15;;;:58;25608:17;;:60;;-1:-1:-1;;;;;25608:17:0;25647:10;25660:7;25608:30;:60::i;:::-;25684:35;;8559:25:1;;;25705:4:0;;25693:10;;25684:35;;8547:2:1;8532:18;25684:35:0;;;;;;;24949:778;;;;;:::o;12014:301::-;12082:12;;-1:-1:-1;;;;;12082:12:0;12115:10;:27;;12107:72;;;;-1:-1:-1;;;12107:72:0;;7485:2:1;12107:72:0;;;7467:21:1;;;7504:18;;;7497:30;7563:34;7543:18;;;7536:62;7615:18;;12107:72:0;7457:182:1;12107:72:0;12218:5;;;12197:42;;-1:-1:-1;;;;;12197:42:0;;;;12218:5;;;12197:42;;;12250:5;:21;;-1:-1:-1;;;;;12250:21:0;;;-1:-1:-1;;;;;;12250:21:0;;;;;;;12282:25;;;;;;;12014:301::o;23355:654::-;23407:21;23431:8;23440:4;23431:14;;;;;;-1:-1:-1;;;23431:14:0;;;;;;;;;;;;;;;;;;;;;;23479:19;;;;23431:14;;-1:-1:-1;23479:19:0;;23460:15;:38;23456:77;;23515:7;23355:654;:::o;23456:77::-;23549:28;;;;23545:132;;23599:19;;:45;;-1:-1:-1;;23599:45:0;23628:15;23599:45;;;;;-1:-1:-1;23355:654:0:o;23545:132::-;23722:19;;;;23687:18;;23708:51;;23722:19;;23743:15;23708:13;:51::i;:::-;23687:72;;23770:17;23849:15;;23831:4;:15;;;;;;;;;;;;23803:43;;23816:12;;23803:10;:25;;;;:::i;:::-;:43;;;;:::i;:::-;:61;;;;:::i;:::-;23917:28;;;;23770:94;;-1:-1:-1;23898:16:0;23770:94;23910:4;23898:16;:::i;:::-;:47;;;;:::i;:::-;23875:4;:19;;;:70;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;23956:19:0;;:45;;-1:-1:-1;;23956:45:0;23985:15;23956:45;;;;;-1:-1:-1;23355:654:0:o;25802:443::-;25861:21;25885:8;25894:4;25885:14;;;;;;-1:-1:-1;;;25885:14:0;;;;;;;;;;;;;;;;;25934;;;25885;25934;;;;;;;25949:10;25934:26;;;;;;;;25992:11;;25885:14;;;;;26014:28;;;:42;;25885:14;;-1:-1:-1;25934:26:0;;25992:11;;26014:28;:42;;25992:11;;26014:42;:::i;:::-;;;;-1:-1:-1;;26074:14:0;;;;:8;:14;;;;;;;;26089:10;26074:26;;;;;;;26067:33;;;;;;;;;;;;;;;26111:17;;:63;;-1:-1:-1;;;;;26111:17:0;;;;26163:10;26111:30;:63::i;:::-;26190:47;;8559:25:1;;;26220:4:0;;26208:10;;26190:47;;8547:2:1;8532:18;26190:47:0;;;;;;;;25802:443;;;;:::o;23099:180::-;23161:8;:15;23144:14;23187:85;23215:6;23209:3;:12;23187:85;;;23245:15;23256:3;23245:10;:15::i;:::-;23223:5;;;:::i;:::-;;;23187:85;;;;23099:180;:::o;21794:369::-;21893:7;21934:9;21926:17;;:5;:17;:37;;21954:9;21926:37;;;;;21946:5;21926:37;21986:7;;21918:45;;-1:-1:-1;21986:7:0;;21978:15;;;:34;;;22003:9;21997:15;;:3;:15;21978:34;21974:75;;;-1:-1:-1;22036:1:0;22029:8;;21974:75;22069:7;;;;22063:13;;22059:68;;;22100:7;;:15;;22110:5;;22100:7;;:15;:::i;:::-;22093:22;;;;22059:68;22144:11;22150:5;22144:3;:11;:::i;:::-;22137:18;;21794:369;;;;;:::o;20569:652::-;12377:5;;-1:-1:-1;;;;;12377:5:0;12363:10;:19;12355:64;;;;-1:-1:-1;;;12355:64:0;;;;;;;:::i;:::-;20710:11:::1;20706:61;;;20738:17;:15;:17::i;:::-;20777:22;20833:9;20815:27;;:15;:27;:57;;20863:9;20815:57;;;;;20845:15;20815:57;20777:95;;20901:11;20883:29;;:15;;:29;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;20951:251:0::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;20951:251:0;;::::1;::::0;;-1:-1:-1;20951:251:0::1;::::0;::::1;::::0;;;;;;;;;::::1;::::0;;::::1;::::0;;;;;;::::1;::::0;;::::1;::::0;;;;;;20923:8:::1;:290:::0;;::::1;::::0;::::1;::::0;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;;;::::1;-1:-1:-1::0;;;;;;20923:290:0;;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;::::1;::::0;::::1;-1:-1:-1::0;;20923:290:0;;;;::::1;::::0;;;;::::1;::::0;;;-1:-1:-1;20569:652:0:o;19484:101::-;12377:5;;-1:-1:-1;;;;;12377:5:0;12363:10;:19;12355:64;;;;-1:-1:-1;;;12355:64:0;;;;;;;:::i;:::-;19556:7:::1;:21:::0;;19567:10;;19556:7;::::1;::::0;:21:::1;::::0;19567:10;;19556:21:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;19484:101:::0;:::o;21386:333::-;12377:5;;-1:-1:-1;;;;;12377:5:0;12363:10;:19;12355:64;;;;-1:-1:-1;;;12355:64:0;;;;;;;:::i;:::-;21519:11:::1;21515:61;;;21547:17;:15;:17::i;:::-;21650:11;21604:57;;21622:8;21631:4;21622:14;;;;;;-1:-1:-1::0;;;21622:14:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:25;;::::0;21604:15:::1;::::0;:43:::1;::::0;21622:25;;::::1;;;::::0;21604:43:::1;:::i;:::-;:57;;;;:::i;:::-;21586:15;:75;;;;21700:11;21672:8;21681:4;21672:14;;;;;;-1:-1:-1::0;;;21672:14:0::1;;;;;;;;;;;;;;;;;;;:25;;;:39;;;;;;;;;;;;;;;;;;21386:333:::0;;;:::o;24083:809::-;24149:21;24173:8;24182:4;24173:14;;;;;;-1:-1:-1;;;24173:14:0;;;;;;;;;;;;;;;;;24222;;;24173;24222;;;;;;;24237:10;24222:26;;;;;;;;;24173:14;;;;;;-1:-1:-1;24259:16:0;24231:4;24259:10;:16::i;:::-;24290:11;;:15;24286:257;;24322:15;24418:4;:28;;;24400:4;:15;;;24393:4;24371;:19;;;24357:4;:11;;;:33;;;;:::i;:::-;:40;;;;:::i;:::-;:58;;;;:::i;:::-;:89;;;;:::i;:::-;24322:124;;24492:39;24511:10;24523:7;24492:18;:39::i;:::-;24461:28;;;:70;-1:-1:-1;24286:257:0;24553:17;;:129;;-1:-1:-1;;;;;24553:17:0;24610:10;24644:4;24664:7;24553:34;:129::i;:::-;24708:7;24693:4;:11;;;:22;;;;;;;:::i;:::-;;;;;;;;24758:7;24726:4;:28;;;:39;;;;;;;:::i;:::-;;;;-1:-1:-1;;24808:19:0;;;;24794:11;;24830:4;;24794:33;;;:::i;:::-;:40;;;;:::i;:::-;24776:15;;;:58;24850:34;;8559:25:1;;;24870:4:0;;24858:10;;24850:34;;8547:2:1;8532:18;24850:34:0;8514:76:1;19918:203:0;12377:5;;-1:-1:-1;;;;;12377:5:0;12363:10;:19;12355:64;;;;-1:-1:-1;;;12355:64:0;;;;;;;:::i;:::-;20019:11:::1;20015:61;;;20047:17;:15;:17::i;:::-;-1:-1:-1::0;20086:12:0::1;:27:::0;19918:203::o;22225:791::-;22324:7;22349:21;22373:8;22382:4;22373:14;;;;;;-1:-1:-1;;;22373:14:0;;;;;;;;;;;;;;;;;22422;;;22373;22422;;;;;;;-1:-1:-1;;;;;22422:21:0;;;;;;;;;;;22373:14;;;;;22479:19;;;;22540;;;;22373:14;;-1:-1:-1;22479:19:0;22540;;22522:15;:37;:74;;;;-1:-1:-1;22563:28:0;;;;:33;;22522:74;22518:389;;;22665:19;;;;22613:18;;22651:51;;22665:19;;22686:15;22651:13;:51::i;:::-;22613:89;;22717:17;22800:15;;22782:4;:15;;;;;;;;;;;;22754:43;;22767:12;;22754:10;:25;;;;:::i;:::-;:43;;;;:::i;:::-;:61;;;;:::i;:::-;22867:28;;;;22717:98;;-1:-1:-1;22848:16:0;22717:98;22860:4;22848:16;:::i;:::-;:47;;;;:::i;:::-;22830:65;;;;:::i;:::-;;;22518:389;;;22980:28;;;;22962:15;;;;22924:11;;22955:4;;22924:28;;22938:14;;22924:28;:::i;:::-;:35;;;;:::i;:::-;:53;;;;:::i;:::-;:84;;;;:::i;:::-;22917:91;22225:791;-1:-1:-1;;;;;;22225:791:0:o;26412:487::-;26533:28;;-1:-1:-1;;;26533:28:0;;26555:4;26533:28;;;3886:51:1;26487:7:0;;;;-1:-1:-1;;;;;26533:3:0;:13;;;;3859:18:1;;26533:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26507:54;-1:-1:-1;26576:20:0;26572:87;;26640:7;26633:14;;;;;26572:87;26683:15;26673:7;:25;26669:163;;;26735:38;-1:-1:-1;;;;;26735:3:0;:16;26752:3;26757:15;26735:16;:38::i;:::-;26795:25;26805:15;26795:7;:25;:::i;:::-;26788:32;;;;;26669:163;26842:30;-1:-1:-1;;;;;26842:3:0;:16;26859:3;26864:7;26842:16;:30::i;:::-;-1:-1:-1;26890:1:0;;26412:487;-1:-1:-1;;;26412:487:0:o;12972:177::-;13082:58;;-1:-1:-1;;;;;4520:32:1;;13082:58:0;;;4502:51:1;4569:18;;;4562:34;;;13055:86:0;;13075:5;;-1:-1:-1;;;13105:23:0;4475:18:1;;13082:58:0;;;;-1:-1:-1;;13082:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;13082:58:0;-1:-1:-1;;;;;;13082:58:0;;;;;;;;;;13055:19;:86::i;13157:205::-;13285:68;;-1:-1:-1;;;;;4206:15:1;;;13285:68:0;;;4188:34:1;4258:15;;4238:18;;;4231:43;4290:18;;;4283:34;;;13258:96:0;;13278:5;;-1:-1:-1;;;13308:27:0;4123:18:1;;13285:68:0;4105:218:1;13258:96:0;13157:205;;;;:::o;15406:761::-;15830:23;15856:69;15884:4;15856:69;;;;;;;;;;;;;;;;;15864:5;-1:-1:-1;;;;;15856:27:0;;;:69;;;;;:::i;:::-;15940:17;;15830:95;;-1:-1:-1;15940:21:0;15936:224;;16082:10;16071:30;;;;;;;;;;;;:::i;:::-;16063:85;;;;-1:-1:-1;;;16063:85:0;;8204:2:1;16063:85:0;;;8186:21:1;8243:2;8223:18;;;8216:30;8282:34;8262:18;;;8255:62;-1:-1:-1;;;8333:18:1;;;8326:40;8383:19;;16063:85:0;8176:232:1;3732:195:0;3835:12;3867:52;3889:6;3897:4;3903:1;3906:12;3867:21;:52::i;:::-;3860:59;;3732:195;;;;;;:::o;4784:530::-;4911:12;4969:5;4944:21;:30;;4936:81;;;;-1:-1:-1;;;4936:81:0;;6303:2:1;4936:81:0;;;6285:21:1;6342:2;6322:18;;;6315:30;6381:34;6361:18;;;6354:62;-1:-1:-1;;;6432:18:1;;;6425:36;6478:19;;4936:81:0;6275:228:1;4936:81:0;1181:20;;5028:60;;;;-1:-1:-1;;;5028:60:0;;7846:2:1;5028:60:0;;;7828:21:1;7885:2;7865:18;;;7858:30;7924:31;7904:18;;;7897:59;7973:18;;5028:60:0;7818:179:1;5028:60:0;5162:12;5176:23;5203:6;-1:-1:-1;;;;;5203:11:0;5223:5;5231:4;5203:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5161:75;;;;5254:52;5272:7;5281:10;5293:12;5254:17;:52::i;:::-;5247:59;4784:530;-1:-1:-1;;;;;;;4784:530:0:o;7324:742::-;7439:12;7468:7;7464:595;;;-1:-1:-1;7499:10:0;7492:17;;7464:595;7613:17;;:21;7609:439;;7876:10;7870:17;7937:15;7924:10;7920:2;7916:19;7909:44;7824:148;8019:12;8012:20;;-1:-1:-1;;;8012:20:0;;;;;;;;:::i;14:159:1:-;81:20;;141:6;130:18;;120:29;;110:2;;163:1;160;153:12;110:2;62:111;;;:::o;178:527::-;249:6;257;265;318:2;306:9;297:7;293:23;289:32;286:2;;;339:6;331;324:22;286:2;383:9;370:23;402:31;427:5;402:31;:::i;:::-;452:5;-1:-1:-1;509:2:1;494:18;;481:32;522:30;481:32;522:30;:::i;:::-;571:7;-1:-1:-1;630:2:1;615:18;;602:32;643:30;602:32;643:30;:::i;:::-;692:7;682:17;;;276:429;;;;;:::o;710:255::-;777:6;830:2;818:9;809:7;805:23;801:32;798:2;;;851:6;843;836:22;798:2;888:9;882:16;907:28;929:5;907:28;:::i;970:478::-;1057:6;1065;1073;1126:2;1114:9;1105:7;1101:23;1097:32;1094:2;;;1147:6;1139;1132:22;1094:2;1175:28;1193:9;1175:28;:::i;:::-;1165:38;;1253:2;1242:9;1238:18;1225:32;1266:31;1291:5;1266:31;:::i;1453:190::-;1512:6;1565:2;1553:9;1544:7;1540:23;1536:32;1533:2;;;1586:6;1578;1571:22;1533:2;-1:-1:-1;1614:23:1;;1523:120;-1:-1:-1;1523:120:1:o;1648:194::-;1718:6;1771:2;1759:9;1750:7;1746:23;1742:32;1739:2;;;1792:6;1784;1777:22;1739:2;-1:-1:-1;1820:16:1;;1729:113;-1:-1:-1;1729:113:1:o;1847:325::-;1915:6;1923;1976:2;1964:9;1955:7;1951:23;1947:32;1944:2;;;1997:6;1989;1982:22;1944:2;2038:9;2025:23;2015:33;;2098:2;2087:9;2083:18;2070:32;2111:31;2136:5;2111:31;:::i;:::-;2161:5;2151:15;;;1934:238;;;;;:::o;2177:319::-;2242:6;2250;2303:2;2291:9;2282:7;2278:23;2274:32;2271:2;;;2324:6;2316;2309:22;2271:2;2365:9;2352:23;2342:33;;2425:2;2414:9;2410:18;2397:32;2438:28;2460:5;2438:28;:::i;2501:391::-;2574:6;2582;2590;2643:2;2631:9;2622:7;2618:23;2614:32;2611:2;;;2664:6;2656;2649:22;2611:2;2705:9;2692:23;2682:33;;2734:37;2767:2;2756:9;2752:18;2734:37;:::i;2897:258::-;2965:6;2973;3026:2;3014:9;3005:7;3001:23;2997:32;2994:2;;;3047:6;3039;3032:22;2994:2;-1:-1:-1;;3075:23:1;;;3145:2;3130:18;;;3117:32;;-1:-1:-1;2984:171:1:o;3160:296::-;3218:6;3271:2;3259:9;3250:7;3246:23;3242:32;3239:2;;;3292:6;3284;3277:22;3239:2;3336:9;3323:23;3386:10;3379:5;3375:22;3368:5;3365:33;3355:2;;3417:6;3409;3402:22;3461:274;3590:3;3628:6;3622:13;3644:53;3690:6;3685:3;3678:4;3670:6;3666:17;3644:53;:::i;:::-;3713:16;;;;;3598:137;-1:-1:-1;;3598:137:1:o;5363:383::-;5512:2;5501:9;5494:21;5475:4;5544:6;5538:13;5587:6;5582:2;5571:9;5567:18;5560:34;5603:66;5662:6;5657:2;5646:9;5642:18;5637:2;5629:6;5625:15;5603:66;:::i;:::-;5730:2;5709:15;-1:-1:-1;;5705:29:1;5690:45;;;;5737:2;5686:54;;5484:262;-1:-1:-1;;5484:262:1:o;6922:356::-;7124:2;7106:21;;;7143:18;;;7136:30;7202:34;7197:2;7182:18;;7175:62;7269:2;7254:18;;7096:182::o;9116:128::-;9156:3;9187:1;9183:6;9180:1;9177:13;9174:2;;;9193:18;;:::i;:::-;-1:-1:-1;9229:9:1;;9164:80::o;9249:228::-;9288:3;9316:10;9353:2;9350:1;9346:10;9383:2;9380:1;9376:10;9414:3;9410:2;9406:12;9401:3;9398:21;9395:2;;;9422:18;;:::i;:::-;9458:13;;9296:181;-1:-1:-1;;;;9296:181:1:o;9482:217::-;9522:1;9548;9538:2;;-1:-1:-1;;;9573:31:1;;9627:4;9624:1;9617:15;9655:4;9580:1;9645:15;9538:2;-1:-1:-1;9684:9:1;;9528:171::o;9704:168::-;9744:7;9810:1;9806;9802:6;9798:14;9795:1;9792:21;9787:1;9780:9;9773:17;9769:45;9766:2;;;9817:18;;:::i;:::-;-1:-1:-1;9857:9:1;;9756:116::o;9877:125::-;9917:4;9945:1;9942;9939:8;9936:2;;;9950:18;;:::i;:::-;-1:-1:-1;9987:9:1;;9926:76::o;10007:258::-;10079:1;10089:113;10103:6;10100:1;10097:13;10089:113;;;10179:11;;;10173:18;10160:11;;;10153:39;10125:2;10118:10;10089:113;;;10220:6;10217:1;10214:13;10211:2;;;-1:-1:-1;;10255:1:1;10237:16;;10230:27;10060:205::o;10270:135::-;10309:3;-1:-1:-1;;10330:17:1;;10327:2;;;10350:18;;:::i;:::-;-1:-1:-1;10397:1:1;10386:13;;10317:88::o;10410:127::-;10471:10;10466:3;10462:20;10459:1;10452:31;10502:4;10499:1;10492:15;10526:4;10523:1;10516:15;10542:131;-1:-1:-1;;;;;10617:31:1;;10607:42;;10597:2;;10663:1;10660;10653:12;10597:2;10587:86;:::o;10678:118::-;10764:5;10757:13;10750:21;10743:5;10740:32;10730:2;;10786:1;10783;10776:12

ipfs://6726c27de323609c7a95c1f25218a25c802a3ddb1e86b631f2c9e6128ce5adc6