Contract 0x2dE1D367a08067447B17dd76d61B4Fc284E4DcDA

/**
 *Submitted for verification at snowtrace.io on 2022-02-16
*/

// File: contracts/snowcones/gauge-proxy-v2.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.6.7; //^0.7.5;

library SafeMath {
    function add(uint a, uint b) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, "add: +");

        return c;
    }
    function add(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        uint c = a + b;
        require(c >= a, errorMessage);

        return c;
    }
    function sub(uint a, uint b) internal pure returns (uint) {
        return sub(a, b, "sub: -");
    }
    function sub(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        require(b <= a, errorMessage);
        uint c = a - b;

        return c;
    }
    function mul(uint a, uint b) internal pure returns (uint) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint c = a * b;
        require(c / a == b, "mul: *");

        return c;
    }
    function mul(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        if (a == 0) {
            return 0;
        }

        uint c = a * b;
        require(c / a == b, errorMessage);

        return c;
    }
    function div(uint a, uint b) internal pure returns (uint) {
        return div(a, b, "div: /");
    }
    function div(uint a, uint b, string memory errorMessage) internal pure returns (uint) {
        require(b > 0, errorMessage);
        uint c = a / b;

        return c;
    }
}

library Address {
    function isContract(address account) internal view returns (bool) {
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != 0x0 && codehash != accountHash);
    }
    function toPayable(address account) internal pure returns (address payable) {
        return address(uint160(account));
    }
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-call-value
        (bool success, ) = recipient.call{value:amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
}

interface IERC20 {
    function totalSupply() external view returns (uint256);
    function balanceOf(address account) external view returns (uint256);
    function transfer(address recipient, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}

library SafeERC20 {
    using SafeMath for uint256;
    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));
    }

    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        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).add(value);
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }
    function callOptionalReturn(IERC20 token, bytes memory data) private {
        require(address(token).isContract(), "SafeERC20: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = address(token).call(data);
        require(success, "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");
        }
    }
}

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

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

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

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor () public {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

contract ProtocolGovernance {
    /// @notice governance address for the governance contract
    address public governance;
    address public pendingGovernance;
    
    /**
     * @notice modifier to allow for easy gov only control over a function
     */
    modifier onlyGovernance() {
        require(msg.sender == governance, "unauthorized sender (governance");
        _;
    }
    
    /**
     * @notice Allows governance to change governance (for future upgradability)
     * @param _governance new governance address to set
     */
    function setGovernance(address _governance) external onlyGovernance{
        pendingGovernance = _governance;
    }

    /**
     * @notice Allows pendingGovernance to accept their role as governance (protection pattern)
     */
    function acceptGovernance() external {
        require(msg.sender == pendingGovernance, "acceptGovernance: !pendingGov");
        governance = pendingGovernance;
    }
}

contract Strategist {
    /// @notice strategist address for the strategist contract
    address public strategist;
    address public pendingStrategist;

    /**
     * @notice modifier to allow for easy gov only control over a function
     */
    modifier onlyStrategist() {
        require(msg.sender == strategist, "unauthorized sender (strategist)");
        _;
    }
    
    /**
     * @notice Allows strategist to change strategist (for future upgradability)
     * @param _strategist new strategist address to set
     */
    function setStrategist(address _strategist) external onlyStrategist {
        pendingStrategist = _strategist;
    }

    /**
     * @notice Allows pendingStrategist to accept their role as strategist (protection pattern)
     */
    function acceptStrategist() external {
        require(msg.sender == pendingStrategist, "unauthorized sender (pendingStrategist)");
        strategist = pendingStrategist;
    }
}

contract GaugeV2 is ReentrancyGuard, ProtocolGovernance {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    
	//FUJI testnet
    IERC20 public constant SNOWBALL = IERC20(0xC38f41A296A4493Ff429F1238e030924A1542e50);
    IERC20 public constant SNOWCONE = IERC20(0x83952E7ab4aca74ca96217D6F8f7591BEaD6D64E);
    address public constant TREASURY = address(0x294aB3200ef36200db84C4128b7f1b4eec71E38a);
    
    IERC20 public immutable TOKEN;
    address public DISTRIBUTION;
    uint256 public constant DURATION = 7 days;
    
    uint256 public periodFinish = 0;
    uint256 public rewardRate = 0;
    uint256 public lastUpdateTime;
    uint256 public rewardPerTokenStored;
    
    modifier onlyDistribution() {
        require(msg.sender == DISTRIBUTION, "Caller is not RewardsDistribution contract");
        _;
    }
    
    mapping(address => uint256) public userRewardPerTokenPaid;
    mapping(address => uint256) public rewards;

    uint256 private _totalSupply;
    uint public derivedSupply;
    mapping(address => uint256) private _balances;
    mapping(address => uint256) public derivedBalances;
    mapping(address => uint) private _base;
    
    constructor(address _token, address _governance) public {
        TOKEN = IERC20(_token);
        DISTRIBUTION = msg.sender;
        governance = _governance;
    }

    // This function is to allow us to update the gaugeProxy 
    // without resetting the old gauges.
    function changeDistribution(address _distribution) external onlyGovernance {
        DISTRIBUTION = _distribution;
    }
    
    function totalSupply() external view returns (uint256) {
        return _totalSupply;
    }

    function balanceOf(address account) external view returns (uint256) {
        return _balances[account];
    }

    function lastTimeRewardApplicable() public view returns (uint256) {
        return Math.min(block.timestamp, periodFinish);
    }

    function rewardPerToken() public view returns (uint256) {
        if (_totalSupply == 0) {
            return rewardPerTokenStored;
        }
        return
            rewardPerTokenStored.add(
                lastTimeRewardApplicable().sub(lastUpdateTime).mul(rewardRate).mul(1e18).div(derivedSupply)
            );
    }
    
    function derivedBalance(address account) public view returns (uint) {
        uint _balance = _balances[account];
        uint _derived = _balance.mul(40).div(100);
        uint _adjusted = (_totalSupply.mul(SNOWCONE.balanceOf(account)).div(SNOWCONE.totalSupply())).mul(60).div(100);
        return Math.min(_derived.add(_adjusted), _balance);
    }
    
    function kick(address account) public {
        uint _derivedBalance = derivedBalances[account];
        derivedSupply = derivedSupply.sub(_derivedBalance);
        _derivedBalance = derivedBalance(account);
        derivedBalances[account] = _derivedBalance;
        derivedSupply = derivedSupply.add(_derivedBalance);
    }

    function earned(address account) public view returns (uint256) {
        return derivedBalances[account].mul(rewardPerToken().sub(userRewardPerTokenPaid[account])).div(1e18).add(rewards[account]);
    }

    function getRewardForDuration() external view returns (uint256) {
        return rewardRate.mul(DURATION);
    }
    
    function depositAll() external {
        _deposit(TOKEN.balanceOf(msg.sender), msg.sender);
    }
    
    function deposit(uint256 amount) external {
        _deposit(amount, msg.sender);
    }
    
    function depositFor(uint256 amount, address account) external {
        _deposit(amount, account);
    }
    
    function _deposit(uint amount, address account) internal nonReentrant updateReward(account) {
        require(amount > 0, "Cannot stake 0");
        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Staked(account, amount);
        TOKEN.safeTransferFrom(account, address(this), amount);
    }
    
    function withdrawAll() external {
        _withdraw(_balances[msg.sender]);
    }

    function withdraw(uint256 amount) external {
        _withdraw(amount);
    }
    
    function _withdraw(uint amount) internal nonReentrant updateReward(msg.sender) {
        require(amount > 0, "Cannot withdraw 0");
        _totalSupply = _totalSupply.sub(amount);
        _balances[msg.sender] = _balances[msg.sender].sub(amount);
        TOKEN.safeTransfer(msg.sender, amount);
        emit Withdrawn(msg.sender, amount);
    }

    function getReward() public nonReentrant updateReward(msg.sender) {
        uint256 reward = rewards[msg.sender];
        if (reward > 0) {
            rewards[msg.sender] = 0;
            SNOWBALL.safeTransfer(msg.sender, reward);
            emit RewardPaid(msg.sender, reward);
        }
    }

    function exit() external {
       _withdraw(_balances[msg.sender]);
        getReward();
    }
    
    function notifyRewardAmount(uint256 reward) external onlyDistribution updateReward(address(0)) {
        SNOWBALL.safeTransferFrom(DISTRIBUTION, address(this), reward);
        if (block.timestamp >= periodFinish) {
            rewardRate = reward.div(DURATION);
        } else {
            uint256 remaining = periodFinish.sub(block.timestamp);
            uint256 leftover = remaining.mul(rewardRate);
            rewardRate = reward.add(leftover).div(DURATION);
        }

        // Ensure the provided reward amount is not more than the balance in the contract.
        // This keeps the reward rate in the right range, preventing overflows due to
        // very high values of rewardRate in the earned and rewardsPerToken functions;
        // Reward + leftover must be less than 2^256 / 10^18 to avoid overflow.
        uint balance = SNOWBALL.balanceOf(address(this));
        require(rewardRate <= balance.div(DURATION), "Provided reward too high");

        lastUpdateTime = block.timestamp;
        periodFinish = block.timestamp.add(DURATION);
        emit RewardAdded(reward);
    }

    modifier updateReward(address account) {
        rewardPerTokenStored = rewardPerToken();
        lastUpdateTime = lastTimeRewardApplicable();
        if (account != address(0)) {
            rewards[account] = earned(account);
            userRewardPerTokenPaid[account] = rewardPerTokenStored;
        }
        _;
        if (account != address(0)) {
            kick(account);
        }
    }

    event RewardAdded(uint256 reward);
    event Staked(address indexed user, uint256 amount);
    event Withdrawn(address indexed user, uint256 amount);
    event RewardPaid(address indexed user, uint256 reward);
}

interface IceQueen {
    function deposit(uint, uint) external;
    function withdraw(uint, uint) external;
    function userInfo(uint, address) external view returns (uint, uint);
}


contract MakeSnowCones {
    using SafeMath for uint;

    /// @notice EIP-20 token name for this token
    string public constant name = "Make SNOWCONES";

    /// @notice EIP-20 token symbol for this token
    string public constant symbol = "mSNOWCONES";

    /// @notice EIP-20 token decimals for this token
    uint8 public constant decimals = 18;

    /// @notice Total number of tokens in circulation
    uint public totalSupply = 1e18;

    mapping (address => mapping (address => uint)) internal allowances;
    mapping (address => uint) internal balances;

    /// @notice The standard EIP-20 transfer event
    event Transfer(address indexed from, address indexed to, uint amount);

    /// @notice The standard EIP-20 approval event
    event Approval(address indexed owner, address indexed spender, uint amount);
    
    constructor() public {
        balances[msg.sender] = 1e18;
        emit Transfer(address(0x0), msg.sender, 1e18);
    }

    /**
     * @notice Get the number of tokens `spender` is approved to spend on behalf of `account`
     * @param account The address of the account holding the funds
     * @param spender The address of the account spending the funds
     * @return The number of tokens approved
     */
    function allowance(address account, address spender) external view returns (uint) {
        return allowances[account][spender];
    }

    /**
     * @notice Approve `spender` to transfer up to `amount` from `src`
     * @dev This will overwrite the approval amount for `spender`
     *  and is subject to issues noted [here](https://eips.ethereum.org/EIPS/eip-20#approve)
     * @param spender The address of the account which may transfer tokens
     * @param amount The number of tokens that are approved (2^256-1 means infinite)
     * @return Whether or not the approval succeeded
     */
    function approve(address spender, uint amount) external returns (bool) {
        allowances[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);
        return true;
    }

    /**
     * @notice Get the number of tokens held by the `account`
     * @param account The address of the account to get the balance of
     * @return The number of tokens held
     */
    function balanceOf(address account) external view returns (uint) {
        return balances[account];
    }

    /**
     * @notice Transfer `amount` tokens from `msg.sender` to `dst`
     * @param dst The address of the destination account
     * @param amount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transfer(address dst, uint amount) external returns (bool) {
        _transferTokens(msg.sender, dst, amount);
        return true;
    }

    /**
     * @notice Transfer `amount` tokens from `src` to `dst`
     * @param src The address of the source account
     * @param dst The address of the destination account
     * @param amount The number of tokens to transfer
     * @return Whether or not the transfer succeeded
     */
    function transferFrom(address src, address dst, uint amount) external returns (bool) {
        address spender = msg.sender;
        uint spenderAllowance = allowances[src][spender];

        if (spender != src && spenderAllowance != uint(-1)) {
            uint newAllowance = spenderAllowance.sub(amount, "transferFrom: exceeds spender allowance");
            allowances[src][spender] = newAllowance;

            emit Approval(src, spender, newAllowance);
        }

        _transferTokens(src, dst, amount);
        return true;
    }

    function _transferTokens(address src, address dst, uint amount) internal {
        require(src != address(0), "_transferTokens: zero address");
        require(dst != address(0), "_transferTokens: zero address");

        balances[src] = balances[src].sub(amount, "_transferTokens: exceeds balance");
        balances[dst] = balances[dst].add(amount, "_transferTokens: overflows");
        emit Transfer(src, dst, amount);
    }
}

contract GaugeProxyV2 is ProtocolGovernance, Strategist {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    
    IceQueen public constant MASTER = IceQueen(0xB12531a2d758c7a8BF09f44FC88E646E1BF9D375);
    IERC20 public constant SNOWCONE = IERC20(0x83952E7ab4aca74ca96217D6F8f7591BEaD6D64E);
    IERC20 public constant SNOWBALL = IERC20(0xC38f41A296A4493Ff429F1238e030924A1542e50);
    
    IERC20 public immutable TOKEN;
    uint public immutable DISTRIBUTION_DEADLINE = 21600;
    
    uint public pid;
    uint public totalWeight;
    uint private lockedTotalWeight;
    uint private lockedBalance;
    uint private locktime;
    
    address[] internal _tokens;
    mapping(address => address) public gauges; // token => gauge
    mapping(address => address) public deprecated; // token => gauge
    mapping(address => uint) public weights; // token => weight
    mapping(address => uint) private lockedWeights; // token => weight
    mapping(address => mapping(address => uint)) public votes; // msg.sender => token => votes
    mapping(address => address[]) public tokenVote;// msg.sender => token
    mapping(address => uint) public usedWeights;  // msg.sender => total voting weight of user
    mapping(address => bool) public deployers;
    


    function addDeployer(address _deployer) external onlyGovernance {
        deployers[_deployer] = true;
    }

    function removeDeployer(address _deployer) external onlyGovernance {
        deployers[_deployer] = false;
    }

    modifier onlyBenevolent {
        require(
            msg.sender == strategist ||
            msg.sender == governance, "unauthorized sender"
        );
        _;
    }
    
    function tokens() external view returns (address[] memory) {
        return _tokens;
    }
    
    function getGauge(address _token) external view returns (address) {
        return gauges[_token];
    }
    
    constructor() public {
        TOKEN = IERC20(address(new MakeSnowCones()));
        governance = msg.sender;
    }
    
    // Reset votes to 0
    function reset() external {
        _reset(msg.sender);
    }
    
    // Reset votes to 0
    function _reset(address _owner) internal {
        address[] storage _tokenVote = tokenVote[_owner];
        uint256 _tokenVoteCnt = _tokenVote.length;

        for (uint i = 0; i < _tokenVoteCnt; i ++) {
            address _token = _tokenVote[i];
            uint _votes = votes[_owner][_token];
            
            if (_votes > 0) {
                totalWeight = totalWeight.sub(_votes);
                weights[_token] = weights[_token].sub(_votes);
                
                votes[_owner][_token] = 0;
            }
        }

        delete tokenVote[_owner];
    }
    
    // Adjusts _owner's votes according to latest _owner's SNOWCONE balance
    function poke(address _owner) public {
        address[] memory _tokenVote = tokenVote[_owner];
        uint256 _tokenCnt = _tokenVote.length;
        uint256[] memory _weights = new uint[](_tokenCnt);
        
        uint256 _prevUsedWeight = usedWeights[_owner];
        uint256 _weight = SNOWCONE.balanceOf(_owner);        

        for (uint256 i = 0; i < _tokenCnt; i ++) {
            uint256 _prevWeight = votes[_owner][_tokenVote[i]];
            _weights[i] = _prevWeight.mul(_weight).div(_prevUsedWeight);
        }

        _vote(_owner, _tokenVote, _weights);
    }
    
    function _vote(address _owner, address[] memory _tokenVote, uint256[] memory _weights) internal {
        // _weights[i] = percentage * 100
        _reset(_owner);
        uint256 _tokenCnt = _tokenVote.length;
        uint256 _weight = SNOWCONE.balanceOf(_owner);
        uint256 _totalVoteWeight = 0;
        uint256 _usedWeight = 0;

        for (uint256 i = 0; i < _tokenCnt; i ++) {
            _totalVoteWeight = _totalVoteWeight.add(_weights[i]);
        }

        for (uint256 i = 0; i < _tokenCnt; i ++) {
            address _token = _tokenVote[i];
            address _gauge = gauges[_token];
            uint256 _tokenWeight = _weights[i].mul(_weight).div(_totalVoteWeight);

            if (_gauge != address(0x0)) {
                _usedWeight = _usedWeight.add(_tokenWeight);
                totalWeight = totalWeight.add(_tokenWeight);
                weights[_token] = weights[_token].add(_tokenWeight);
                tokenVote[_owner].push(_token);
                votes[_owner][_token] = _tokenWeight;
            }
        }

        usedWeights[_owner] = _usedWeight;
    }
    
    
    // Vote with SNOWCONE on a gauge
    // _tokenVote: the array of tokens which will recieve tokens
    // _weights: the weights to associate with the tokens listed in _tokenVote
    function vote(address[] calldata _tokenVote, uint256[] calldata _weights) external {
        require(_tokenVote.length == _weights.length);
        _vote(msg.sender, _tokenVote, _weights);
    }
    
    // Add new token gauge
    function addGauge(address _token) external onlyBenevolent {
        require(gauges[_token] == address(0x0), "exists");
        gauges[_token] = address(new GaugeV2(_token, governance));
        _tokens.push(_token);
    }

    // Deprecate existing gauge
    function deprecateGauge(address _token) external onlyBenevolent {
        require(gauges[_token] != address(0x0), "does not exist");
        deprecated[_token] = gauges[_token];
        delete gauges[_token];
        totalWeight = totalWeight.sub(weights[_token]);
        delete weights[_token];
    }

    // Bring Deprecated gauge back into use
    function renewGauge(address _token) external onlyBenevolent {
        require(gauges[_token] == address(0x0), "exists");
        gauges[_token] = deprecated[_token];
        delete deprecated[_token];
    }

    // Add existing gauge
    function migrateGauge(address _gauge, address _token) external onlyBenevolent {
        require(gauges[_token] == address(0x0), "exists");
        gauges[_token] = _gauge;
        _tokens.push(_token);
    }
    
    // Sets IceQueen PID
    function setPID(uint _pid) external onlyGovernance {
        require(pid == 0, "pid has already been set");
        require(_pid > 0, "invalid pid");
        pid = _pid;
    }
    
    
    // Deposits mSNOWCONES into IceQueen
    function deposit() public {
        require(pid > 0, "pid not initialized");
        IERC20 _token = TOKEN;
        uint _balance = _token.balanceOf(address(this));
        _token.safeApprove(address(MASTER), 0);
        _token.safeApprove(address(MASTER), _balance);
        MASTER.deposit(pid, _balance);
    }
    
    
    // Fetches Snowball
    function collect() public {
        (uint _locked,) = MASTER.userInfo(pid, address(this));
        MASTER.withdraw(pid, _locked);
        deposit();
    }
    
    function length() external view returns (uint) {
        return _tokens.length;
    }

    function preDistribute() external {
        require(
            deployers[msg.sender] ||
            msg.sender == strategist ||
            msg.sender == governance, "unauthorized sender"
        );
        lockedTotalWeight = totalWeight;
        for (uint i = 0; i < _tokens.length; i++) {
          lockedWeights[_tokens[i]] = weights[_tokens[i]];
        }
        collect();
        lockedBalance = SNOWBALL.balanceOf(address(this));
        locktime = block.timestamp;
    }

    
    function distribute(uint _start, uint _end) external {
        require(
            deployers[msg.sender] ||
            msg.sender == strategist ||
            msg.sender == governance, "unauthorized sender"
        );
        require(_start < _end, "bad _start");
        require(_end <= _tokens.length, "bad _end");
        require(locktime + DISTRIBUTION_DEADLINE >= block.timestamp, "lock expired");
        if (lockedBalance > 0 && lockedTotalWeight > 0) {
            for (uint i = _start; i < _end; i++) {
                address _token = _tokens[i];
                address _gauge = gauges[_token];
                uint _reward = lockedBalance.mul(lockedWeights[_token]).div(totalWeight);
                if (_reward > 0) {
                    SNOWBALL.safeApprove(_gauge, 0);
                    SNOWBALL.safeApprove(_gauge, _reward);
                    GaugeV2(_gauge).notifyRewardAmount(_reward);
                }
            }
        }
    }
}

[{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"address","name":"_governance","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrawn","type":"event"},{"inputs":[],"name":"DISTRIBUTION","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DURATION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SNOWBALL","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SNOWCONE","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TOKEN","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"TREASURY","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_distribution","type":"address"}],"name":"changeDistribution","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"depositFor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"derivedBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"derivedBalances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"derivedSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"earned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"exit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getRewardForDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"kick","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastTimeRewardApplicable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"name":"notifyRewardAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pendingGovernance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"periodFinish","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"rewards","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_governance","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"userRewardPerTokenPaid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000008665e1fad19d14b16eecb96a7608cd42962e7eeb0000000000000000000000003d88b8022142ea2693ba43ba349f89256392d59b

-----Decoded View---------------
Arg [0] : _token (address): 0x8665e1fad19d14b16eecb96a7608cd42962e7eeb
Arg [1] : _governance (address): 0x3d88b8022142ea2693ba43ba349f89256392d59b

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000008665e1fad19d14b16eecb96a7608cd42962e7eeb
Arg [1] : 0000000000000000000000003d88b8022142ea2693ba43ba349f89256392d59b

10529:6791:0:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;10529:6791:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;13561:204:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13561:204:0;-1:-1:-1;;;;;13561:204:0;;:::i;:::-;;;;;;;;;;;;;;;;11460:42;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11460:42:0;-1:-1:-1;;;;;11460:42:0;;:::i;12153:93::-;;;:::i;11032:41::-;;;:::i;13773:114::-;;;:::i;9371:170::-;;;:::i;:::-;;10863:86;;;:::i;:::-;;;;-1:-1:-1;;;;;10863:86:0;;;;;;;;;;;;;;14696:79;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14696:79:0;;:::i;14111:106::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14111:106:0;;;;;;-1:-1:-1;;;;;14111:106:0;;:::i;15565:1117::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;15565:1117:0;;:::i;15145:303::-;;;:::i;8666:25::-;;;:::i;12019:122::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12019:122:0;-1:-1:-1;;;;;12019:122:0;;:::i;11630:50::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11630:50:0;-1:-1:-1;;;;;11630:50:0;;:::i;10772:84::-;;;:::i;12254:112::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12254:112:0;-1:-1:-1;;;;;12254:112:0;;:::i;11124:29::-;;;:::i;10998:27::-;;;:::i;12374:131::-;;;:::i;10962:29::-;;;:::i;14605:83::-;;;:::i;11396:57::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11396:57:0;-1:-1:-1;;;;;11396:57:0;;:::i;13222:331::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13222:331:0;-1:-1:-1;;;;;13222:331:0;;:::i;9131:117::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;9131:117:0;-1:-1:-1;;;;;9131:117:0;;:::i;14010:89::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14010:89:0;;:::i;11160:29::-;;;:::i;12513:331::-;;;:::i;12856:354::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12856:354:0;-1:-1:-1;;;;;12856:354:0;;:::i;11546:25::-;;;:::i;13899:99::-;;;:::i;11196:35::-;;;:::i;15456:97::-;;;:::i;11086:31::-;;;:::i;10681:84::-;;;:::i;8698:32::-;;;:::i;13561:204::-;-1:-1:-1;;;;;13740:16:0;;13615:7;13740:16;;;:7;:16;;;;;;;;;13692:22;:31;;;;;;13642:115;;13740:16;13642:93;;13730:4;;13642:83;;13671:53;;:16;:14;:16::i;:::-;:20;:53;:20;:53;:::i;:::-;-1:-1:-1;;;;;13642:24:0;;;;;;:15;:24;;;;;;;:28;:83::i;:::-;:87;:93;:87;:93;:::i;:::-;:97;:115;:97;:115;:::i;:::-;13635:122;13561:204;-1:-1:-1;;13561:204:0:o;11460:42::-;;;;;;;;;;;;;:::o;12153:93::-;12226:12;;12153:93;;:::o;11032:41::-;11067:6;11032:41;:::o;13773:114::-;13855:10;;13828:7;;13855:24;;11067:6;13855:24;:14;:24;:::i;:::-;13848:31;;13773:114;:::o;9371:170::-;9441:17;;-1:-1:-1;;;;;9441:17:0;9427:10;:31;9419:73;;;;;-1:-1:-1;;;9419:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9516:17;;;9503:30;;-1:-1:-1;;;;;;9503:30:0;-1:-1:-1;;;;;9516:17:0;;;9503:30;;;;;;9371:170::o;10863:86::-;10906:42;10863:86;:::o;14696:79::-;14750:17;14760:6;14750:9;:17::i;:::-;14696:79;:::o;14111:106::-;14184:25;14193:6;14201:7;14184:8;:25::i;:::-;14111:106;;:::o;15565:1117::-;11305:12;;-1:-1:-1;;;;;11305:12:0;11291:10;:26;11283:81;;;;-1:-1:-1;;;11283:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15656:1:::1;16763:16;:14;:16::i;:::-;16740:20;:39:::0;16807:26:::1;:24;:26::i;:::-;16790:14;:43:::0;-1:-1:-1;;;;;16848:21:0;::::1;::::0;16844:157:::1;;16905:15;16912:7;16905:6;:15::i;:::-;-1:-1:-1::0;;;;;16886:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;16969:20:::1;::::0;16935:22:::1;:31:::0;;;;;;:54;16844:157:::1;15697:12:::2;::::0;15671:62:::2;::::0;10722:42:::2;::::0;-1:-1:-1;;;;;15697:12:0::2;15719:4;15726:6:::0;15671:25:::2;:62::i;:::-;15767:12;;15748:15;:31;15744:304;;15809:20;:6:::0;11067::::2;15809:20;:10;:20;:::i;:::-;15796:10;:33:::0;15744:304:::2;;;15882:12;::::0;15862:17:::2;::::0;15882:33:::2;::::0;15899:15:::2;15882:33;:16;:33;:::i;:::-;15862:53;;15930:16;15949:25;15963:10;;15949:9;:13;;:25;;;;:::i;:::-;15930:44:::0;-1:-1:-1;16002:34:0::2;11067:6;16002:20;:6:::0;15930:44;16002:20:::2;:10;:20;:::i;:34::-;15989:10;:47:::0;-1:-1:-1;;15744:304:0::2;16423:33;::::0;;-1:-1:-1;;;16423:33:0;;16450:4:::2;16423:33;::::0;::::2;::::0;;;-1:-1:-1;;10722:42:0::2;::::0;-1:-1:-1;;16423:33:0;;;;;::::2;::::0;;;;;;;;;10722:42;16423:33;::::2;;2:2:-1::0;::::2;;;27:1;24::::0;17:12:::2;2:2;16423:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::2;77:16;74:1;67:27;5:2;16423:33:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::2;4:2;-1:-1:::0;16423:33:0;;-1:-1:-1;16489:21:0::2;16423:33:::0;11067:6:::2;16489:21;:11;:21;:::i;:::-;16475:10;;:35;;16467:72;;;::::0;;-1:-1:-1;;;16467:72:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;::::2;::::0;;;;;;;;;;;;;::::2;;16569:15;16552:14;:32:::0;;;16610:29:::2;::::0;11067:6:::2;16610:29;:19;:29;:::i;:::-;16595:12;:44:::0;16655:19:::2;::::0;;;;;;;::::2;::::0;;;;::::2;::::0;;::::2;-1:-1:-1::0;;;;;;17027:21:0;::::1;::::0;17023:67:::1;;17065:13;17070:7;17065:4;:13::i;15145:303::-:0;7614:1;8218:7;;:19;;8210:63;;;;;-1:-1:-1;;;8210:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7614:1;8351:7;:18;15199:10:::1;16763:16;:14;:16::i;:::-;16740:20;:39:::0;16807:26:::1;:24;:26::i;:::-;16790:14;:43:::0;-1:-1:-1;;;;;16848:21:0;::::1;::::0;16844:157:::1;;16905:15;16912:7;16905:6;:15::i;:::-;-1:-1:-1::0;;;;;16886:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;16969:20:::1;::::0;16935:22:::1;:31:::0;;;;;;:54;16844:157:::1;15247:10:::2;15222:14;15239:19:::0;;;:7:::2;:19;::::0;;;;;15273:10;;15269:172:::2;;15308:10;15322:1;15300:19:::0;;;:7:::2;:19;::::0;;;;:23;15338:41:::2;::::0;10722:42:::2;::::0;15372:6;15338:41:::2;:21;:41;:::i;:::-;15399:30;::::0;;;;;;;15410:10:::2;::::0;15399:30:::2;::::0;;;;;::::2;::::0;;::::2;15269:172;-1:-1:-1::0;;;;;;17027:21:0;::::1;::::0;17023:67:::1;;17065:13;17070:7;17065:4;:13::i;:::-;-1:-1:-1::0;7570:1:0;8530:7;:22;15145:303::o;8666:25::-;;;-1:-1:-1;;;;;8666:25:0;;:::o;12019:122::-;8896:10;;-1:-1:-1;;;;;8896:10:0;8882;:24;8874:68;;;;;-1:-1:-1;;;8874:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12105:12:::1;:28:::0;;-1:-1:-1;;;;;;12105:28:0::1;-1:-1:-1::0;;;;;12105:28:0;;;::::1;::::0;;;::::1;::::0;;12019:122::o;11630:50::-;;;;;;;;;;;;;:::o;10772:84::-;10813:42;10772:84;:::o;12254:112::-;-1:-1:-1;;;;;12340:18:0;12313:7;12340:18;;;:9;:18;;;;;;;12254:112::o;11124:29::-;;;;:::o;10998:27::-;;;-1:-1:-1;;;;;10998:27:0;;:::o;12374:131::-;12431:7;12458:39;12467:15;12484:12;;12458:8;:39::i;10962:29::-;;;:::o;14605:83::-;14668:10;14658:21;;;;:9;:21;;;;;;14648:32;;:9;:32::i;:::-;14605:83::o;11396:57::-;;;;;;;;;;;;;:::o;13222:331::-;-1:-1:-1;;;;;13294:24:0;;13271:20;13294:24;;;:15;:24;;;;;;13345:13;;:34;;13294:24;13345:17;:34::i;:::-;13329:13;:50;13408:23;13423:7;13408:14;:23::i;:::-;-1:-1:-1;;;;;13442:24:0;;;;;;:15;:24;;;;;:42;;;13511:13;;13442:42;;-1:-1:-1;13511:34:0;;13442:42;13511:17;:34::i;:::-;13495:13;:50;-1:-1:-1;;13222:331:0:o;9131:117::-;8896:10;;-1:-1:-1;;;;;8896:10:0;8882;:24;8874:68;;;;;-1:-1:-1;;;8874:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9209:17:::1;:31:::0;;-1:-1:-1;;;;;;9209:31:0::1;-1:-1:-1::0;;;;;9209:31:0;;;::::1;::::0;;;::::1;::::0;;9131:117::o;14010:89::-;14063:28;14072:6;14080:10;14063:8;:28::i;11160:29::-;;;;:::o;12513:331::-;12560:7;12584:12;;12600:1;12584:17;12580:77;;;-1:-1:-1;12625:20:0;;12618:27;;12580:77;12687:149;12730:91;12807:13;;12730:72;12797:4;12730:62;12781:10;;12730:46;12761:14;;12730:26;:24;:26::i;:46::-;:50;:62;:50;:62;:::i;:91::-;12687:20;;;:149;:24;:149;:::i;12856:354::-;-1:-1:-1;;;;;12951:18:0;;12918:4;12951:18;;;:9;:18;;;;;;12918:4;12996:25;13017:3;12996:16;12951:18;13009:2;12996:12;:16::i;:25::-;12980:41;;13032:14;13049:92;13137:3;13049:83;13129:2;13050:73;10813:42;-1:-1:-1;;;;;13100:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;13100:22:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13100:22:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13100:22:0;13067:27;;;-1:-1:-1;;;13067:27:0;;-1:-1:-1;;;;;13067:27:0;;;;;;;;13050:45;;10813:42;;-1:-1:-1;;13067:27:0;;;;;13100:22;;13067:27;;;;;;;;10813:42;13067:27;;;2:2:-1;;;;27:1;24;17:12;2:2;13067:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13067:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13067:27:0;13050:12;;;:45;:16;:45;:::i;13049:92::-;13032:109;-1:-1:-1;13159:43:0;13168:23;:8;13032:109;13168:23;:12;:23;:::i;:::-;13193:8;13159;:43::i;:::-;13152:50;12856:354;-1:-1:-1;;;;;12856:354:0:o;11546:25::-;;;;:::o;13899:99::-;13950:27;;;-1:-1:-1;;;13950:27:0;;13966:10;13950:27;;;;;;13941:49;;13950:5;-1:-1:-1;;;;;13950:15:0;;-1:-1:-1;;13950:27:0;;;;;;;;;;;;;;;:15;:27;;;2:2:-1;;;;27:1;24;17:12;2:2;13950:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13950:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13950:27:0;13979:10;13941:8;:49::i;11196:35::-;;;;:::o;15456:97::-;15511:10;15501:21;;;;:9;:21;;;;;;15491:32;;:9;:32::i;:::-;15534:11;:9;:11::i;11086:31::-;;;;:::o;10681:84::-;10722:42;10681:84;:::o;8698:32::-;;;-1:-1:-1;;;;;8698:32:0;;:::o;485:103::-;537:4;561:19;565:1;568;561:19;;;;;;;;;;;;;-1:-1:-1;;;561:19:0;;;:3;:19::i;:::-;554:26;485:103;-1:-1:-1;;;485:103:0:o;780:432::-;832:4;1074:6;1070:47;;-1:-1:-1;1104:1:0;1097:8;;1070:47;1138:5;;;1142:1;1138;:5;:1;1162:5;;;;;:10;1154:29;;;;;-1:-1:-1;;;1154:29:0;;;;;;;;;;;;-1:-1:-1;;;1154:29:0;;;;;;;;;;;;;;1467:103;1519:4;1543:19;1547:1;1550;1543:19;;;;;;;;;;;;;-1:-1:-1;;;1543:19:0;;;:3;:19::i;145:148::-;197:4;223:5;;;247:6;;;;239:25;;;;;-1:-1:-1;;;239:25:0;;;;;;;;;;;;-1:-1:-1;;;239:25:0;;;;;;;;;;;;;;14787:350;7614:1;8218:7;;:19;;8210:63;;;;;-1:-1:-1;;;8210:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7614:1;8351:7;:18;14854:10:::1;16763:16;:14;:16::i;:::-;16740:20;:39:::0;16807:26:::1;:24;:26::i;:::-;16790:14;:43:::0;-1:-1:-1;;;;;16848:21:0;::::1;::::0;16844:157:::1;;16905:15;16912:7;16905:6;:15::i;:::-;-1:-1:-1::0;;;;;16886:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;16969:20:::1;::::0;16935:22:::1;:31:::0;;;;;;:54;16844:157:::1;14894:1:::2;14885:6;:10;14877:40;;;::::0;;-1:-1:-1;;;14877:40:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;14877:40:0;;;;;;;;;;;;;::::2;;14943:12;::::0;:24:::2;::::0;14960:6;14943:24:::2;:16;:24;:::i;:::-;14928:12;:39:::0;15012:10:::2;15002:21;::::0;;;:9:::2;:21;::::0;;;;;:33:::2;::::0;15028:6;15002:33:::2;:25;:33;:::i;:::-;14988:10;14978:21;::::0;;;:9:::2;:21;::::0;;;;:57;;;;15046:38:::2;::::0;-1:-1:-1;;;;;15046:5:0::2;:18;::::0;15077:6;15046:18:::2;:38::i;:::-;15100:29;::::0;;;;;;;15110:10:::2;::::0;15100:29:::2;::::0;;;;;::::2;::::0;;::::2;-1:-1:-1::0;;;;;17027:21:0;::::1;::::0;17023:67:::1;;17065:13;17070:7;17065:4;:13::i;:::-;-1:-1:-1::0;;7570:1:0;8530:7;:22;14787:350::o;14229:364::-;7614:1;8218:7;;:19;;8210:63;;;;;-1:-1:-1;;;8210:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7614:1;8351:7;:18;14312:7;16763:16:::1;:14;:16::i;:::-;16740:20;:39:::0;16807:26:::1;:24;:26::i;:::-;16790:14;:43:::0;-1:-1:-1;;;;;16848:21:0;::::1;::::0;16844:157:::1;;16905:15;16912:7;16905:6;:15::i;:::-;-1:-1:-1::0;;;;;16886:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;16969:20:::1;::::0;16935:22:::1;:31:::0;;;;;;:54;16844:157:::1;14349:1:::2;14340:6;:10;14332:37;;;::::0;;-1:-1:-1;;;14332:37:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;14332:37:0;;;;;;;;;;;;;::::2;;14395:12;::::0;:24:::2;::::0;14412:6;14395:24:::2;:16;:24;:::i;:::-;14380:12;:39:::0;-1:-1:-1;;;;;14451:18:0;::::2;;::::0;;;:9:::2;:18;::::0;;;;;:30:::2;::::0;14474:6;14451:22:::2;:30::i;:::-;-1:-1:-1::0;;;;;14430:18:0;::::2;;::::0;;;:9:::2;:18;::::0;;;;;;;;:51;;;;14497:23;;;;;;;14430:18;;14497:23:::2;::::0;;;;;;;::::2;14531:54;:5;-1:-1:-1::0;;;;;14531:22:0::2;14554:7:::0;14571:4:::2;14578:6:::0;14531:22:::2;:54::i;:::-;-1:-1:-1::0;;;;;17027:21:0;::::1;::::0;17023:67:::1;;17065:13;17070:7;17065:4;:13::i;:::-;-1:-1:-1::0;;7570:1:0;8530:7;:22;-1:-1:-1;14229:364:0:o;3467:204::-;3594:68;;;-1:-1:-1;;;;;3594:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;3594:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;3568:95:0;;3587:5;;3568:18;:95::i;:::-;3467:204;;;;:::o;3283:176::-;3392:58;;;-1:-1:-1;;;;;3392:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;3392:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;3366:85:0;;3385:5;;3366:18;:85::i;:::-;3283:176;;;:::o;5538:106::-;5596:7;5627:1;5623;:5;:13;;5635:1;5623:13;;;-1:-1:-1;5631:1:0;;5538:106;-1:-1:-1;5538:106:0:o;594:180::-;674:4;707:12;699:6;;;;691:29;;;;-1:-1:-1;;;691:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:100:-1;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;691:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;740:5:0;;;594:180::o;1576:179::-;1656:4;1688:12;1681:5;1673:28;;;;-1:-1:-1;;;1673:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27:10;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1673:28:0;;1712:6;1725:1;1721;:5;;;;;;;1576:179;-1:-1:-1;;;;;1576:179:0:o;4663:598::-;4751:27;-1:-1:-1;;;;;4751:25:0;;;:27::i;:::-;4743:71;;;;;-1:-1:-1;;;4743:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;4888:12;4902:23;4937:5;-1:-1:-1;;;;;4929:19:0;4949:4;4929:25;;;;;;;;;;;;;36:153:-1;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;4929:25:0;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;19;14:27;;;;67:4;61:11;56:16;;134:4;130:9;123:4;105:16;101:27;97:43;94:1;90:51;84:4;77:65;157:16;154:1;147:27;211:16;208:1;201:4;198:1;194:12;179:49;5:228;;14:27;32:4;27:9;;5:228;;4887:67:0;;;;4973:7;4965:52;;;;;-1:-1:-1;;;4965:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5034:17;;:21;5030:224;;5176:10;5165:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;5165:30:0;5157:85;;;;-1:-1:-1;;;5157:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1785:374;1845:4;2068:20;;1911:66;2108:15;;;;;:42;;;2139:11;2127:8;:23;;2108:42;2100:51;1785:374;-1:-1:-1;;;;1785:374:0:o

ipfs://183450e1fa31e421e43a1c89279cdf73fd640126be89f649b8ec55143e61dfc9