Contract 0x839de324a1ab773f76a53900d70ac1b913d2b387

/**
 *Submitted for verification at arbiscan.io on 2021-09-19
*/

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

[{"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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

0000000000000000000000003e6648c5a70a150a88bce65f4ad4d506fe15d2af0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000006148da30

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

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 0000000000000000000000003e6648c5a70a150a88bce65f4ad4d506fe15d2af
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [2] : 000000000000000000000000000000000000000000000000000000006148da30

16783:10048:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11572:363;;;;;;:::i;:::-;;:::i;:::-;;20095:95;20167:8;:15;20095:95;;;8564:25:1;;;8552:2;8537:18;20095:95:0;;;;;;;;18421:26;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;5098:55:1;;;5080:74;;5185:2;5170:18;;5163:34;;;;5213:18;;;5206:34;;;;5288:10;5276:23;5271:2;5256:18;;5249:51;5349:6;5337:19;5331:3;5316:19;;5309:48;5067:3;5052:19;18421:26:0;4811:552:1;18600:34:0;;;;;;18348:27;;;;;;18818:21;;;;;;;;;;;;9098:10:1;9086:23;;;9068:42;;9056:2;9041:18;18818:21:0;8924:192:1;24878:778:0;;;;;;:::i;:::-;;:::i;18289:27::-;;;;;;;;-1:-1:-1;;;;;3794:55:1;;;3776:74;;3764:2;3749:18;18289:27:0;3630:226:1;11943:301:0;;;:::i;23284:654::-;;;;;;:::i;:::-;;:::i;25731:443::-;;;;;;:::i;:::-;;:::i;23028:180::-;;;:::i;18730:33::-;;;;;11250:20;;;;;-1:-1:-1;;;;;11250:20:0;;;21723:369;;;;;;:::i;:::-;;:::i;18482:64::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8802:25:1;;;8858:2;8843:18;;8836:34;;;;8886:18;;;8879:34;8790:2;8775:18;18482:64:0;8600:319:1;20498:652:0;;;;;;:::i;:::-;;:::i;19413:101::-;;;;;;:::i;:::-;;:::i;21315:333::-;;;;;;:::i;:::-;;:::i;24012:809::-;;;;;;:::i;:::-;;:::i;11277:27::-;;;;;-1:-1:-1;;;;;11277:27:0;;;19847:203;;;;;;:::i;:::-;;:::i;22154:791::-;;;;;;:::i;:::-;;:::i;11572:363::-;12306:5;;-1:-1:-1;;;;;12306:5:0;12292:10;:19;12284:64;;;;-1:-1:-1;;;12284:64:0;;7129:2:1;12284:64:0;;;7111:21:1;;;7148:18;;;7141:30;7207:34;7187:18;;;7180:62;7259:18;;12284:64:0;;;;;;;;;11677:6:::1;11673:255;;;-1:-1:-1::0;;;;;11710:22:0;::::1;::::0;::::1;::::0;:34:::1;;;11736:8;11710:34;11702:68;;;::::0;-1:-1:-1;;;11702:68:0;;5958:2:1;11702:68:0::1;::::0;::::1;5940:21:1::0;5997:2;5977:18;;;5970:30;6036:23;6016:18;;;6009:51;6077:18;;11702:68:0::1;5756:345:1::0;11702:68:0::1;11813:5;::::0;;11792:37:::1;::::0;-1:-1:-1;;;;;11792:37:0;;::::1;::::0;11813:5;::::1;::::0;11792:37:::1;::::0;::::1;11844:5;:16:::0;;-1:-1:-1;;;;;11844:16:0;::::1;-1:-1:-1::0;;11844:16:0;;::::1;;::::0;;11572:363;;;:::o;11673:255::-:1;11893:12;:23:::0;;-1:-1:-1;;11893:23:0::1;-1:-1:-1::0;;;;;11893:23:0;::::1;;::::0;;11673:255:::1;11572:363:::0;;;:::o;18421:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;18421:26:0;;;;-1:-1:-1;18421:26:0;;;;;;;;;;;;:::o;24878:778::-;24945:21;24969:8;24978:4;24969:14;;;;;;;;:::i;:::-;;;;;;;;;25018;;;24969;25018;;;;;;;25033:10;25018:26;;;;;;;;;25063:11;;24969:14;;;;;;;;-1:-1:-1;;;25063:22:0;25055:80;;;;-1:-1:-1;;;25055:80:0;;6715:2:1;25055:80:0;;;6697:21:1;6754:2;6734:18;;;6727:30;6793:34;6773:18;;;6766:62;6864:15;6844:18;;;6837:43;6897:19;;25055:80:0;6513:409:1;25055:80:0;25146:16;25157:4;25146:10;:16::i;:::-;25173:15;25265:4;:28;;;25247:4;:15;;;25240:4;25218;:19;;;25204:4;:11;;;:33;;;;:::i;:::-;:40;;;;:::i;:::-;:58;;;;:::i;:::-;:89;;;;:::i;:::-;25173:120;;25335:39;25354:10;25366:7;25335:18;:39::i;:::-;25304:28;;;:70;25385:22;;25400:7;;25304:4;;25385:11;;:22;;25400:7;;25385:22;:::i;:::-;;;;;;;;25450:7;25418:4;:28;;;:39;;;;;;;:::i;:::-;;;;-1:-1:-1;;25500:19:0;;;;25486:11;;25522:4;;25486:33;;;:::i;:::-;:40;;;;:::i;:::-;25468:15;;;:58;25537:17;;:60;;-1:-1:-1;;;;;25537:17:0;25576:10;25589:7;25537:30;:60::i;:::-;25613:35;;8564:25:1;;;25634:4:0;;25622:10;;25613:35;;8552:2:1;8537:18;25613:35:0;;;;;;;24934:722;;;24878:778;;:::o;11943:301::-;12011:12;;-1:-1:-1;;;;;12011:12:0;12044:10;:27;;12036:72;;;;-1:-1:-1;;;12036:72:0;;7490:2:1;12036:72:0;;;7472:21:1;;;7509:18;;;7502:30;7568:34;7548:18;;;7541:62;7620:18;;12036:72:0;7288:356:1;12036:72:0;12147:5;;;12126:42;;-1:-1:-1;;;;;12126:42:0;;;;12147:5;;;12126:42;;;12179:5;:21;;-1:-1:-1;;;;;12179:21:0;;;-1:-1:-1;;12179:21:0;;;;;;;12211:25;;;;;;;11943:301::o;23284:654::-;23336:21;23360:8;23369:4;23360:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;23408:19;;;;23360:14;;-1:-1:-1;23408:19:0;;23389:15;:38;23385:77;;23444:7;23284:654;:::o;23385:77::-;23478:28;;;;23474:132;;23528:19;;:45;;-1:-1:-1;;23528:45:0;23557:15;23528:45;;;;;-1:-1:-1;23284:654:0:o;23474:132::-;23651:19;;;;23616:18;;23637:51;;23651:19;;23672:15;23637:13;:51::i;:::-;23616:72;;23699:17;23778:15;;23760:4;:15;;;;;;;;;;;;23732:43;;23745:12;;23732:10;:25;;;;:::i;:::-;:43;;;;:::i;:::-;:61;;;;:::i;:::-;23846:28;;;;23699:94;;-1:-1:-1;23827:16:0;23699:94;23839:4;23827:16;:::i;:::-;:47;;;;:::i;:::-;23804:4;:19;;;:70;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;23885:19:0;;:45;;-1:-1:-1;;23885:45:0;23914:15;23885:45;;;;;-1:-1:-1;23284:654:0:o;25731:443::-;25790:21;25814:8;25823:4;25814:14;;;;;;;;:::i;:::-;;;;;;;;;25863;;;25814;25863;;;;;;;25878:10;25863:26;;;;;;;;25921:11;;25814:14;;;;;25943:28;;;:42;;25814:14;;-1:-1:-1;25863:26:0;;25921:11;;25943:28;:42;;25921:11;;25943:42;:::i;:::-;;;;-1:-1:-1;;26003:14:0;;;;:8;:14;;;;;;;;26018:10;26003:26;;;;;;;25996:33;;;;;;;;;;;;;;;26040:17;;:63;;-1:-1:-1;;;;;26040:17:0;;;;26092:10;26040:30;:63::i;:::-;26119:47;;8564:25:1;;;26149:4:0;;26137:10;;26119:47;;8552:2:1;8537:18;26119:47:0;;;;;;;;25779:395;;;25731:443;:::o;23028:180::-;23090:8;:15;23073:14;23116:85;23144:6;23138:3;:12;23116:85;;;23174:15;23185:3;23174:10;:15::i;:::-;23152:5;;;:::i;:::-;;;23116:85;;;;23062:146;23028:180::o;21723:369::-;21822:7;21863:9;21855:17;;:5;:17;:37;;21883:9;21855:37;;;;;21875:5;21855:37;21915:7;;21847:45;;-1:-1:-1;21915:7:0;;21907:15;;;:34;;;21932:9;21926:15;;:3;:15;21907:34;21903:75;;;-1:-1:-1;21965:1:0;21958:8;;21903:75;21998:7;;;;21992:13;;21988:68;;;22029:7;;:15;;22039:5;;22029:7;;:15;:::i;:::-;22022:22;;;;21988:68;22073:11;22079:5;22073:3;:11;:::i;:::-;22066:18;;21723:369;;;;;:::o;20498:652::-;12306:5;;-1:-1:-1;;;;;12306:5:0;12292:10;:19;12284:64;;;;-1:-1:-1;;;12284:64:0;;7129:2:1;12284:64:0;;;7111:21:1;;;7148:18;;;7141:30;7207:34;7187:18;;;7180:62;7259:18;;12284:64:0;6927:356:1;12284:64:0;20639:11:::1;20635:61;;;20667:17;:15;:17::i;:::-;20706:22;20762:9;20744:27;;:15;:27;:57;;20792:9;20744:57;;;;;20774:15;20744:57;20706:95;;20830:11;20812:29;;:15;;:29;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;20880:251:0::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;20880:251:0;;::::1;::::0;;-1:-1:-1;20880:251:0::1;::::0;::::1;::::0;;;;;;;;;::::1;::::0;;::::1;::::0;;;;;;::::1;::::0;;::::1;::::0;;;;;;20852:8:::1;:290:::0;;::::1;::::0;::::1;::::0;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;;;;::::1;-1:-1:-1::0;;20852:290:0;;::::1;::::0;;;::::1;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;::::1;::::0;::::1;-1:-1:-1::0;;20852:290:0;;;;::::1;::::0;;;;::::1;::::0;;;-1:-1:-1;20498:652:0:o;19413:101::-;12306:5;;-1:-1:-1;;;;;12306:5:0;12292:10;:19;12284:64;;;;-1:-1:-1;;;12284:64:0;;7129:2:1;12284:64:0;;;7111:21:1;;;7148:18;;;7141:30;7207:34;7187:18;;;7180:62;7259:18;;12284:64:0;6927:356:1;12284:64:0;19485:7:::1;:21:::0;;19496:10;;19485:7;::::1;::::0;:21:::1;::::0;19496:10;;19485:21:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;19413:101:::0;:::o;21315:333::-;12306:5;;-1:-1:-1;;;;;12306:5:0;12292:10;:19;12284:64;;;;-1:-1:-1;;;12284:64:0;;7129:2:1;12284:64:0;;;7111:21:1;;;7148:18;;;7141:30;7207:34;7187:18;;;7180:62;7259:18;;12284:64:0;6927:356:1;12284:64:0;21448:11:::1;21444:61;;;21476:17;:15;:17::i;:::-;21579:11;21533:57;;21551:8;21560:4;21551:14;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;:25;;::::0;21533:15:::1;::::0;:43:::1;::::0;21551:25;;::::1;;;::::0;21533:43:::1;:::i;:::-;:57;;;;:::i;:::-;21515:15;:75;;;;21629:11;21601:8;21610:4;21601:14;;;;;;;;:::i;:::-;;;;;;;;;;;:25;;;:39;;;;;;;;;;;;;;;;;;21315:333:::0;;;:::o;24012:809::-;24078:21;24102:8;24111:4;24102:14;;;;;;;;:::i;:::-;;;;;;;;;24151;;;24102;24151;;;;;;;24166:10;24151:26;;;;;;;;;24102:14;;;;;;-1:-1:-1;24188:16:0;24160:4;24188:10;:16::i;:::-;24219:11;;:15;24215:257;;24251:15;24347:4;:28;;;24329:4;:15;;;24322:4;24300;:19;;;24286:4;:11;;;:33;;;;:::i;:::-;:40;;;;:::i;:::-;:58;;;;:::i;:::-;:89;;;;:::i;:::-;24251:124;;24421:39;24440:10;24452:7;24421:18;:39::i;:::-;24390:28;;;:70;-1:-1:-1;24215:257:0;24482:17;;:129;;-1:-1:-1;;;;;24482:17:0;24539:10;24573:4;24593:7;24482:34;:129::i;:::-;24637:7;24622:4;:11;;;:22;;;;;;;:::i;:::-;;;;;;;;24687:7;24655:4;:28;;;:39;;;;;;;:::i;:::-;;;;-1:-1:-1;;24737:19:0;;;;24723:11;;24759:4;;24723:33;;;:::i;:::-;:40;;;;:::i;:::-;24705:15;;;:58;24779:34;;8564:25:1;;;24799:4:0;;24787:10;;24779:34;;8552:2:1;8537:18;24779:34:0;8418:177:1;19847:203:0;12306:5;;-1:-1:-1;;;;;12306:5:0;12292:10;:19;12284:64;;;;-1:-1:-1;;;12284:64:0;;7129:2:1;12284:64:0;;;7111:21:1;;;7148:18;;;7141:30;7207:34;7187:18;;;7180:62;7259:18;;12284:64:0;6927:356:1;12284:64:0;19948:11:::1;19944:61;;;19976:17;:15;:17::i;:::-;-1:-1:-1::0;20015:12:0::1;:27:::0;19847:203::o;22154:791::-;22253:7;22278:21;22302:8;22311:4;22302:14;;;;;;;;:::i;:::-;;;;;;;;;22351;;;22302;22351;;;;;;;-1:-1:-1;;;;;22351:21:0;;;;;;;;;;;22302:14;;;;;22408:19;;;;22469;;;;22302:14;;-1:-1:-1;22408:19:0;22469;;22451:15;:37;:74;;;;-1:-1:-1;22492:28:0;;;;:33;;22451:74;22447:389;;;22594:19;;;;22542:18;;22580:51;;22594:19;;22615:15;22580:13;:51::i;:::-;22542:89;;22646:17;22729:15;;22711:4;:15;;;;;;;;;;;;22683:43;;22696:12;;22683:10;:25;;;;:::i;:::-;:43;;;;:::i;:::-;:61;;;;:::i;:::-;22796:28;;;;22646:98;;-1:-1:-1;22777:16:0;22646:98;22789:4;22777:16;:::i;:::-;:47;;;;:::i;:::-;22759:65;;;;:::i;:::-;;;22527:309;;22447:389;22909:28;;;;22891:15;;;;22853:11;;22884:4;;22853:28;;22867:14;;22853:28;:::i;:::-;:35;;;;:::i;:::-;:53;;;;:::i;:::-;:84;;;;:::i;:::-;22846:91;22154:791;-1:-1:-1;;;;;;22154:791:0:o;26341:487::-;26462:28;;;;;26484:4;26462:28;;;3776:74:1;26416:7:0;;;;-1:-1:-1;;;;;26462:3:0;:13;;;;3749:18:1;;26462:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;26436:54;-1:-1:-1;26505:20:0;26501:87;;26569:7;26562:14;;;;;26501:87;26612:15;26602:7;:25;26598:163;;;26664:38;-1:-1:-1;;;;;26664:3:0;:16;26681:3;26686:15;26664:16;:38::i;:::-;26724:25;26734:15;26724:7;:25;:::i;:::-;26717:32;;;;;26598:163;26771:30;-1:-1:-1;;;;;26771:3:0;:16;26788:3;26793:7;26771:16;:30::i;:::-;-1:-1:-1;26819:1:0;;26341:487;-1:-1:-1;;;26341:487:0:o;12901:177::-;13011:58;;-1:-1:-1;;;;;4456:55:1;;13011:58:0;;;4438:74:1;4528:18;;;4521:34;;;12984:86:0;;13004:5;;13034:23;;4411:18:1;;13011:58:0;;;;-1:-1:-1;;13011:58:0;;;;;;;;;;;;;;;;;;;;;;;;;;;12984:19;:86::i;13086:205::-;13214:68;;-1:-1:-1;;;;;4142:15:1;;;13214:68:0;;;4124:34:1;4194:15;;4174:18;;;4167:43;4226:18;;;4219:34;;;13187:96:0;;13207:5;;13237:27;;4036:18:1;;13214:68:0;3861:398:1;13187:96:0;13086:205;;;;:::o;15335:761::-;15759:23;15785:69;15813:4;15785:69;;;;;;;;;;;;;;;;;15793:5;-1:-1:-1;;;;;15785:27:0;;;:69;;;;;:::i;:::-;15869:17;;15759:95;;-1:-1:-1;15869:21:0;15865:224;;16011:10;16000:30;;;;;;;;;;;;:::i;:::-;15992:85;;;;-1:-1:-1;;;15992:85:0;;8209:2:1;15992:85:0;;;8191:21:1;8248:2;8228:18;;;8221:30;8287:34;8267:18;;;8260:62;8358:12;8338:18;;;8331:40;8388:19;;15992:85:0;8007:406:1;3661:195:0;3764:12;3796:52;3818:6;3826:4;3832:1;3835:12;3796:21;:52::i;:::-;3789:59;;3661:195;;;;;;:::o;4713:530::-;4840:12;4898:5;4873:21;:30;;4865:81;;;;-1:-1:-1;;;4865:81:0;;6308:2:1;4865:81:0;;;6290:21:1;6347:2;6327:18;;;6320:30;6386:34;6366:18;;;6359:62;6457:8;6437:18;;;6430:36;6483:19;;4865:81:0;6106:402:1;4865:81:0;1110:20;;4957:60;;;;-1:-1:-1;;;4957:60:0;;7851:2:1;4957:60:0;;;7833:21:1;7890:2;7870:18;;;7863:30;7929:31;7909:18;;;7902:59;7978:18;;4957:60:0;7649:353:1;4957:60:0;5091:12;5105:23;5132:6;-1:-1:-1;;;;;5132:11:0;5152:5;5160:4;5132:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5090:75;;;;5183:52;5201:7;5210:10;5222:12;5183:17;:52::i;:::-;5176:59;4713:530;-1:-1:-1;;;;;;;4713:530:0:o;7253:742::-;7368:12;7397:7;7393:595;;;-1:-1:-1;7428:10:0;7421:17;;7393:595;7542:17;;:21;7538:439;;7805:10;7799:17;7866:15;7853:10;7849:2;7845:19;7838:44;7538:439;7948:12;7941:20;;-1:-1:-1;;;7941:20:0;;;;;;;;:::i;14:159:1:-;81:20;;141:6;130:18;;120:29;;110:57;;163:1;160;153:12;110:57;14:159;;;:::o;178:517::-;249:6;257;265;318:2;306:9;297:7;293:23;289:32;286:52;;;334:1;331;324:12;286:52;373:9;360:23;392:31;417:5;392:31;:::i;:::-;442:5;-1:-1:-1;499:2:1;484:18;;471:32;512:30;471:32;512:30;:::i;:::-;561:7;-1:-1:-1;620:2:1;605:18;;592:32;633:30;592:32;633:30;:::i;:::-;682:7;672:17;;;178:517;;;;;:::o;700:245::-;767:6;820:2;808:9;799:7;795:23;791:32;788:52;;;836:1;833;826:12;788:52;868:9;862:16;887:28;909:5;887:28;:::i;950:468::-;1037:6;1045;1053;1106:2;1094:9;1085:7;1081:23;1077:32;1074:52;;;1122:1;1119;1112:12;1074:52;1145:28;1163:9;1145:28;:::i;:::-;1135:38;;1223:2;1212:9;1208:18;1195:32;1236:31;1261:5;1236:31;:::i;1423:180::-;1482:6;1535:2;1523:9;1514:7;1510:23;1506:32;1503:52;;;1551:1;1548;1541:12;1503:52;-1:-1:-1;1574:23:1;;1423:180;-1:-1:-1;1423:180:1:o;1608:184::-;1678:6;1731:2;1719:9;1710:7;1706:23;1702:32;1699:52;;;1747:1;1744;1737:12;1699:52;-1:-1:-1;1770:16:1;;1608:184;-1:-1:-1;1608:184:1:o;1797:315::-;1865:6;1873;1926:2;1914:9;1905:7;1901:23;1897:32;1894:52;;;1942:1;1939;1932:12;1894:52;1978:9;1965:23;1955:33;;2038:2;2027:9;2023:18;2010:32;2051:31;2076:5;2051:31;:::i;:::-;2101:5;2091:15;;;1797:315;;;;;:::o;2117:309::-;2182:6;2190;2243:2;2231:9;2222:7;2218:23;2214:32;2211:52;;;2259:1;2256;2249:12;2211:52;2295:9;2282:23;2272:33;;2355:2;2344:9;2340:18;2327:32;2368:28;2390:5;2368:28;:::i;2431:381::-;2504:6;2512;2520;2573:2;2561:9;2552:7;2548:23;2544:32;2541:52;;;2589:1;2586;2579:12;2541:52;2625:9;2612:23;2602:33;;2654:37;2687:2;2676:9;2672:18;2654:37;:::i;2817:248::-;2885:6;2893;2946:2;2934:9;2925:7;2921:23;2917:32;2914:52;;;2962:1;2959;2952:12;2914:52;-1:-1:-1;;2985:23:1;;;3055:2;3040:18;;;3027:32;;-1:-1:-1;2817:248:1:o;3070:276::-;3128:6;3181:2;3169:9;3160:7;3156:23;3152:32;3149:52;;;3197:1;3194;3187:12;3149:52;3236:9;3223:23;3286:10;3279:5;3275:22;3268:5;3265:33;3255:61;;3312:1;3309;3302:12;3351:274;3480:3;3518:6;3512:13;3534:53;3580:6;3575:3;3568:4;3560:6;3556:17;3534:53;:::i;:::-;3603:16;;;;;3351:274;-1:-1:-1;;3351:274:1:o;5368:383::-;5517:2;5506:9;5499:21;5480:4;5549:6;5543:13;5592:6;5587:2;5576:9;5572:18;5565:34;5608:66;5667:6;5662:2;5651:9;5647:18;5642:2;5634:6;5630:15;5608:66;:::i;:::-;5735:2;5714:15;-1:-1:-1;;5710:29:1;5695:45;;;;5742:2;5691:54;;5368:383;-1:-1:-1;;5368:383:1:o;9121:128::-;9161:3;9192:1;9188:6;9185:1;9182:13;9179:39;;;9198:18;;:::i;:::-;-1:-1:-1;9234:9:1;;9121:128::o;9254:228::-;9293:3;9321:10;9358:2;9355:1;9351:10;9388:2;9385:1;9381:10;9419:3;9415:2;9411:12;9406:3;9403:21;9400:47;;;9427:18;;:::i;:::-;9463:13;;9254:228;-1:-1:-1;;;;9254:228:1:o;9487:274::-;9527:1;9553;9543:189;;-1:-1:-1;;;9585:1:1;9578:88;9689:4;9686:1;9679:15;9717:4;9714:1;9707:15;9543:189;-1:-1:-1;9746:9:1;;9487:274::o;9766:168::-;9806:7;9872:1;9868;9864:6;9860:14;9857:1;9854:21;9849:1;9842:9;9835:17;9831:45;9828:71;;;9879:18;;:::i;:::-;-1:-1:-1;9919:9:1;;9766:168::o;9939:125::-;9979:4;10007:1;10004;10001:8;9998:34;;;10012:18;;:::i;:::-;-1:-1:-1;10049:9:1;;9939:125::o;10069:258::-;10141:1;10151:113;10165:6;10162:1;10159:13;10151:113;;;10241:11;;;10235:18;10222:11;;;10215:39;10187:2;10180:10;10151:113;;;10282:6;10279:1;10276:13;10273:48;;;-1:-1:-1;;10317:1:1;10299:16;;10292:27;10069:258::o;10332:135::-;10371:3;-1:-1:-1;;10392:17:1;;10389:43;;;10412:18;;:::i;:::-;-1:-1:-1;10459:1:1;10448:13;;10332:135::o;10472:184::-;-1:-1:-1;;;10521:1:1;10514:88;10621:4;10618:1;10611:15;10645:4;10642:1;10635:15;10661:184;-1:-1:-1;;;10710:1:1;10703:88;10810:4;10807:1;10800:15;10834:4;10831:1;10824:15;10850:154;-1:-1:-1;;;;;10929:5:1;10925:54;10918:5;10915:65;10905:93;;10994:1;10991;10984:12;10905:93;10850:154;:::o;11009:118::-;11095:5;11088:13;11081:21;11074:5;11071:32;11061:60;;11117:1;11114;11107:12

ipfs://2d8b8dbfed2bbeb1250717fce6da3618e53fc48699b175b2db12f87b51520456