Contract 0x3605a13e60C5C40d448262c2665d45f7FF06894F

/**
 *Submitted for verification at snowtrace.io on 2021-11-06
*/

/**
 *Submitted for verification at snowtrace.io on 2021-11-06
*/

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

00000000000000000000000032d9d114a2f5ac4ce777463e661bfa28c8fe9eb7000000000000000000000000c9a51fb9057380494262fd291aed74317332c0a2

-----Decoded View---------------
Arg [0] : _token (address): 0x32d9d114a2f5ac4ce777463e661bfa28c8fe9eb7
Arg [1] : _governance (address): 0xc9a51fb9057380494262fd291aed74317332c0a2

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 00000000000000000000000032d9d114a2f5ac4ce777463e661bfa28c8fe9eb7
Arg [1] : 000000000000000000000000c9a51fb9057380494262fd291aed74317332c0a2

10600:6791:0:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;10600:6791:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;13632:204:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13632:204:0;-1:-1:-1;;;;;13632:204:0;;:::i;:::-;;;;;;;;;;;;;;;;11531:42;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11531:42:0;-1:-1:-1;;;;;11531:42:0;;:::i;12224:93::-;;;:::i;11103:41::-;;;:::i;13844:114::-;;;:::i;9442:170::-;;;:::i;:::-;;10934:86;;;:::i;:::-;;;;-1:-1:-1;;;;;10934:86:0;;;;;;;;;;;;;;14767:79;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14767:79:0;;:::i;14182:106::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14182:106:0;;;;;;-1:-1:-1;;;;;14182:106:0;;:::i;15636:1117::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;15636:1117:0;;:::i;15216:303::-;;;:::i;8737:25::-;;;:::i;12090:122::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12090:122:0;-1:-1:-1;;;;;12090:122:0;;:::i;11701:50::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11701:50:0;-1:-1:-1;;;;;11701:50:0;;:::i;10843:84::-;;;:::i;12325:112::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12325:112:0;-1:-1:-1;;;;;12325:112:0;;:::i;11195:29::-;;;:::i;11069:27::-;;;:::i;12445:131::-;;;:::i;11033:29::-;;;:::i;14676:83::-;;;:::i;11467:57::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11467:57:0;-1:-1:-1;;;;;11467:57:0;;:::i;13293:331::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13293:331:0;-1:-1:-1;;;;;13293:331:0;;:::i;9202:117::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;9202:117:0;-1:-1:-1;;;;;9202:117:0;;:::i;14081:89::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14081:89:0;;:::i;11231:29::-;;;:::i;12584:331::-;;;:::i;12927:354::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12927:354:0;-1:-1:-1;;;;;12927:354:0;;:::i;11617:25::-;;;:::i;13970:99::-;;;:::i;11267:35::-;;;:::i;15527:97::-;;;:::i;11157:31::-;;;:::i;10752:84::-;;;:::i;8769:32::-;;;:::i;13632:204::-;-1:-1:-1;;;;;13811:16:0;;13686:7;13811:16;;;:7;:16;;;;;;;;;13763:22;:31;;;;;;13713:115;;13811:16;13713:93;;13801:4;;13713:83;;13742:53;;:16;:14;:16::i;:::-;:20;:53;:20;:53;:::i;:::-;-1:-1:-1;;;;;13713:24:0;;;;;;:15;:24;;;;;;;:28;:83::i;:::-;:87;:93;:87;:93;:::i;:::-;:97;:115;:97;:115;:::i;:::-;13706:122;13632:204;-1:-1:-1;;13632:204:0:o;11531:42::-;;;;;;;;;;;;;:::o;12224:93::-;12297:12;;12224:93;;:::o;11103:41::-;11138:6;11103:41;:::o;13844:114::-;13926:10;;13899:7;;13926:24;;11138:6;13926:24;:14;:24;:::i;:::-;13919:31;;13844:114;:::o;9442:170::-;9512:17;;-1:-1:-1;;;;;9512:17:0;9498:10;:31;9490:73;;;;;-1:-1:-1;;;9490:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9587:17;;;9574:30;;-1:-1:-1;;;;;;9574:30:0;-1:-1:-1;;;;;9587:17:0;;;9574:30;;;;;;9442:170::o;10934:86::-;10977:42;10934:86;:::o;14767:79::-;14821:17;14831:6;14821:9;:17::i;:::-;14767:79;:::o;14182:106::-;14255:25;14264:6;14272:7;14255:8;:25::i;:::-;14182:106;;:::o;15636:1117::-;11376:12;;-1:-1:-1;;;;;11376:12:0;11362:10;:26;11354:81;;;;-1:-1:-1;;;11354:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15727:1:::1;16834:16;:14;:16::i;:::-;16811:20;:39:::0;16878:26:::1;:24;:26::i;:::-;16861:14;:43:::0;-1:-1:-1;;;;;16919:21:0;::::1;::::0;16915:157:::1;;16976:15;16983:7;16976:6;:15::i;:::-;-1:-1:-1::0;;;;;16957:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;17040:20:::1;::::0;17006:22:::1;:31:::0;;;;;;:54;16915:157:::1;15768:12:::2;::::0;15742:62:::2;::::0;10793:42:::2;::::0;-1:-1:-1;;;;;15768:12:0::2;15790:4;15797:6:::0;15742:25:::2;:62::i;:::-;15838:12;;15819:15;:31;15815:304;;15880:20;:6:::0;11138::::2;15880:20;:10;:20;:::i;:::-;15867:10;:33:::0;15815:304:::2;;;15953:12;::::0;15933:17:::2;::::0;15953:33:::2;::::0;15970:15:::2;15953:33;:16;:33;:::i;:::-;15933:53;;16001:16;16020:25;16034:10;;16020:9;:13;;:25;;;;:::i;:::-;16001:44:::0;-1:-1:-1;16073:34:0::2;11138:6;16073:20;:6:::0;16001:44;16073:20:::2;:10;:20;:::i;:34::-;16060:10;:47:::0;-1:-1:-1;;15815:304:0::2;16494:33;::::0;;-1:-1:-1;;;16494:33:0;;16521:4:::2;16494:33;::::0;::::2;::::0;;;-1:-1:-1;;10793:42:0::2;::::0;-1:-1:-1;;16494:33:0;;;;;::::2;::::0;;;;;;;;;10793:42;16494:33;::::2;;2:2:-1::0;::::2;;;27:1;24::::0;17:12:::2;2:2;16494:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::2;77:16;74:1;67:27;5:2;16494:33:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::2;4:2;-1:-1:::0;16494:33:0;;-1:-1:-1;16560:21:0::2;16494:33:::0;11138:6:::2;16560:21;:11;:21;:::i;:::-;16546:10;;:35;;16538:72;;;::::0;;-1:-1:-1;;;16538:72:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;::::2;::::0;;;;;;;;;;;;;::::2;;16640:15;16623:14;:32:::0;;;16681:29:::2;::::0;11138:6:::2;16681:29;:19;:29;:::i;:::-;16666:12;:44:::0;16726:19:::2;::::0;;;;;;;::::2;::::0;;;;::::2;::::0;;::::2;-1:-1:-1::0;;;;;;17098:21:0;::::1;::::0;17094:67:::1;;17136:13;17141:7;17136:4;:13::i;15216:303::-:0;7685:1;8289:7;;:19;;8281:63;;;;;-1:-1:-1;;;8281:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7685:1;8422:7;:18;15270:10:::1;16834:16;:14;:16::i;:::-;16811:20;:39:::0;16878:26:::1;:24;:26::i;:::-;16861:14;:43:::0;-1:-1:-1;;;;;16919:21:0;::::1;::::0;16915:157:::1;;16976:15;16983:7;16976:6;:15::i;:::-;-1:-1:-1::0;;;;;16957:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;17040:20:::1;::::0;17006:22:::1;:31:::0;;;;;;:54;16915:157:::1;15318:10:::2;15293:14;15310:19:::0;;;:7:::2;:19;::::0;;;;;15344:10;;15340:172:::2;;15379:10;15393:1;15371:19:::0;;;:7:::2;:19;::::0;;;;:23;15409:41:::2;::::0;10793:42:::2;::::0;15443:6;15409:41:::2;:21;:41;:::i;:::-;15470:30;::::0;;;;;;;15481:10:::2;::::0;15470:30:::2;::::0;;;;;::::2;::::0;;::::2;15340:172;-1:-1:-1::0;;;;;;17098:21:0;::::1;::::0;17094:67:::1;;17136:13;17141:7;17136:4;:13::i;:::-;-1:-1:-1::0;7641:1:0;8601:7;:22;15216:303::o;8737:25::-;;;-1:-1:-1;;;;;8737:25:0;;:::o;12090:122::-;8967:10;;-1:-1:-1;;;;;8967:10:0;8953;:24;8945:68;;;;;-1:-1:-1;;;8945:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12176:12:::1;:28:::0;;-1:-1:-1;;;;;;12176:28:0::1;-1:-1:-1::0;;;;;12176:28:0;;;::::1;::::0;;;::::1;::::0;;12090:122::o;11701:50::-;;;;;;;;;;;;;:::o;10843:84::-;10884:42;10843:84;:::o;12325:112::-;-1:-1:-1;;;;;12411:18:0;12384:7;12411:18;;;:9;:18;;;;;;;12325:112::o;11195:29::-;;;;:::o;11069:27::-;;;-1:-1:-1;;;;;11069:27:0;;:::o;12445:131::-;12502:7;12529:39;12538:15;12555:12;;12529:8;:39::i;11033:29::-;;;:::o;14676:83::-;14739:10;14729:21;;;;:9;:21;;;;;;14719:32;;:9;:32::i;:::-;14676:83::o;11467:57::-;;;;;;;;;;;;;:::o;13293:331::-;-1:-1:-1;;;;;13365:24:0;;13342:20;13365:24;;;:15;:24;;;;;;13416:13;;:34;;13365:24;13416:17;:34::i;:::-;13400:13;:50;13479:23;13494:7;13479:14;:23::i;:::-;-1:-1:-1;;;;;13513:24:0;;;;;;:15;:24;;;;;:42;;;13582:13;;13513:42;;-1:-1:-1;13582:34:0;;13513:42;13582:17;:34::i;:::-;13566:13;:50;-1:-1:-1;;13293:331:0:o;9202:117::-;8967:10;;-1:-1:-1;;;;;8967:10:0;8953;:24;8945:68;;;;;-1:-1:-1;;;8945:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9280:17:::1;:31:::0;;-1:-1:-1;;;;;;9280:31:0::1;-1:-1:-1::0;;;;;9280:31:0;;;::::1;::::0;;;::::1;::::0;;9202:117::o;14081:89::-;14134:28;14143:6;14151:10;14134:8;:28::i;11231:29::-;;;;:::o;12584:331::-;12631:7;12655:12;;12671:1;12655:17;12651:77;;;-1:-1:-1;12696:20:0;;12689:27;;12651:77;12758:149;12801:91;12878:13;;12801:72;12868:4;12801:62;12852:10;;12801:46;12832:14;;12801:26;:24;:26::i;:46::-;:50;:62;:50;:62;:::i;:91::-;12758:20;;;:149;:24;:149;:::i;12927:354::-;-1:-1:-1;;;;;13022:18:0;;12989:4;13022:18;;;:9;:18;;;;;;12989:4;13067:25;13088:3;13067:16;13022:18;13080:2;13067:12;:16::i;:25::-;13051:41;;13103:14;13120:92;13208:3;13120:83;13200:2;13121:73;10884:42;-1:-1:-1;;;;;13171:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;13171:22:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13171:22:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13171:22:0;13138:27;;;-1:-1:-1;;;13138:27:0;;-1:-1:-1;;;;;13138:27:0;;;;;;;;13121:45;;10884:42;;-1:-1:-1;;13138:27:0;;;;;13171:22;;13138:27;;;;;;;;10884:42;13138:27;;;2:2:-1;;;;27:1;24;17:12;2:2;13138:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13138:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13138:27:0;13121:12;;;:45;:16;:45;:::i;13120:92::-;13103:109;-1:-1:-1;13230:43:0;13239:23;:8;13103:109;13239:23;:12;:23;:::i;:::-;13264:8;13230;:43::i;:::-;13223:50;12927:354;-1:-1:-1;;;;;12927:354:0:o;11617:25::-;;;;:::o;13970:99::-;14021:27;;;-1:-1:-1;;;14021:27:0;;14037:10;14021:27;;;;;;14012:49;;14021:5;-1:-1:-1;;;;;14021:15:0;;-1:-1:-1;;14021:27:0;;;;;;;;;;;;;;;:15;:27;;;2:2:-1;;;;27:1;24;17:12;2:2;14021:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14021:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14021:27:0;14050:10;14012:8;:49::i;11267:35::-;;;;:::o;15527:97::-;15582:10;15572:21;;;;:9;:21;;;;;;15562:32;;:9;:32::i;:::-;15605:11;:9;:11::i;11157:31::-;;;;:::o;10752:84::-;10793:42;10752:84;:::o;8769:32::-;;;-1:-1:-1;;;;;8769:32:0;;:::o;556:103::-;608:4;632:19;636:1;639;632:19;;;;;;;;;;;;;-1:-1:-1;;;632:19:0;;;:3;:19::i;:::-;625:26;556:103;-1:-1:-1;;;556:103:0:o;851:432::-;903:4;1145:6;1141:47;;-1:-1:-1;1175:1:0;1168:8;;1141:47;1209:5;;;1213:1;1209;:5;:1;1233:5;;;;;:10;1225:29;;;;;-1:-1:-1;;;1225:29:0;;;;;;;;;;;;-1:-1:-1;;;1225:29:0;;;;;;;;;;;;;;1538:103;1590:4;1614:19;1618:1;1621;1614:19;;;;;;;;;;;;;-1:-1:-1;;;1614:19:0;;;:3;:19::i;216:148::-;268:4;294:5;;;318:6;;;;310:25;;;;;-1:-1:-1;;;310:25:0;;;;;;;;;;;;-1:-1:-1;;;310:25:0;;;;;;;;;;;;;;14858:350;7685:1;8289:7;;:19;;8281:63;;;;;-1:-1:-1;;;8281:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7685:1;8422:7;:18;14925:10:::1;16834:16;:14;:16::i;:::-;16811:20;:39:::0;16878:26:::1;:24;:26::i;:::-;16861:14;:43:::0;-1:-1:-1;;;;;16919:21:0;::::1;::::0;16915:157:::1;;16976:15;16983:7;16976:6;:15::i;:::-;-1:-1:-1::0;;;;;16957:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;17040:20:::1;::::0;17006:22:::1;:31:::0;;;;;;:54;16915:157:::1;14965:1:::2;14956:6;:10;14948:40;;;::::0;;-1:-1:-1;;;14948:40:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;14948:40:0;;;;;;;;;;;;;::::2;;15014:12;::::0;:24:::2;::::0;15031:6;15014:24:::2;:16;:24;:::i;:::-;14999:12;:39:::0;15083:10:::2;15073:21;::::0;;;:9:::2;:21;::::0;;;;;:33:::2;::::0;15099:6;15073:33:::2;:25;:33;:::i;:::-;15059:10;15049:21;::::0;;;:9:::2;:21;::::0;;;;:57;;;;15117:38:::2;::::0;-1:-1:-1;;;;;15117:5:0::2;:18;::::0;15148:6;15117:18:::2;:38::i;:::-;15171:29;::::0;;;;;;;15181:10:::2;::::0;15171:29:::2;::::0;;;;;::::2;::::0;;::::2;-1:-1:-1::0;;;;;17098:21:0;::::1;::::0;17094:67:::1;;17136:13;17141:7;17136:4;:13::i;:::-;-1:-1:-1::0;;7641:1:0;8601:7;:22;14858:350::o;14300:364::-;7685:1;8289:7;;:19;;8281:63;;;;;-1:-1:-1;;;8281:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7685:1;8422:7;:18;14383:7;16834:16:::1;:14;:16::i;:::-;16811:20;:39:::0;16878:26:::1;:24;:26::i;:::-;16861:14;:43:::0;-1:-1:-1;;;;;16919:21:0;::::1;::::0;16915:157:::1;;16976:15;16983:7;16976:6;:15::i;:::-;-1:-1:-1::0;;;;;16957:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;17040:20:::1;::::0;17006:22:::1;:31:::0;;;;;;:54;16915:157:::1;14420:1:::2;14411:6;:10;14403:37;;;::::0;;-1:-1:-1;;;14403:37:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;14403:37:0;;;;;;;;;;;;;::::2;;14466:12;::::0;:24:::2;::::0;14483:6;14466:24:::2;:16;:24;:::i;:::-;14451:12;:39:::0;-1:-1:-1;;;;;14522:18:0;::::2;;::::0;;;:9:::2;:18;::::0;;;;;:30:::2;::::0;14545:6;14522:22:::2;:30::i;:::-;-1:-1:-1::0;;;;;14501:18:0;::::2;;::::0;;;:9:::2;:18;::::0;;;;;;;;:51;;;;14568:23;;;;;;;14501:18;;14568:23:::2;::::0;;;;;;;::::2;14602:54;:5;-1:-1:-1::0;;;;;14602:22:0::2;14625:7:::0;14642:4:::2;14649:6:::0;14602:22:::2;:54::i;:::-;-1:-1:-1::0;;;;;17098:21:0;::::1;::::0;17094:67:::1;;17136:13;17141:7;17136:4;:13::i;:::-;-1:-1:-1::0;;7641:1:0;8601:7;:22;-1:-1:-1;14300:364:0:o;3538:204::-;3665:68;;;-1:-1:-1;;;;;3665:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;3665:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;3639:95:0;;3658:5;;3639:18;:95::i;:::-;3538:204;;;;:::o;3354:176::-;3463:58;;;-1:-1:-1;;;;;3463:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;3463:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;3437:85:0;;3456:5;;3437:18;:85::i;:::-;3354:176;;;:::o;5609:106::-;5667:7;5698:1;5694;:5;:13;;5706:1;5694:13;;;-1:-1:-1;5702:1:0;;5609:106;-1:-1:-1;5609:106:0:o;665:180::-;745:4;778:12;770:6;;;;762:29;;;;-1:-1:-1;;;762: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;762:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;811:5:0;;;665:180::o;1647:179::-;1727:4;1759:12;1752:5;1744:28;;;;-1:-1:-1;;;1744:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27:10;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1744:28:0;;1783:6;1796:1;1792;:5;;;;;;;1647:179;-1:-1:-1;;;;;1647:179:0:o;4734:598::-;4822:27;-1:-1:-1;;;;;4822:25:0;;;:27::i;:::-;4814:71;;;;;-1:-1:-1;;;4814:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;4959:12;4973:23;5008:5;-1:-1:-1;;;;;5000:19:0;5020:4;5000: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;;;5000: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;;4958:67:0;;;;5044:7;5036:52;;;;;-1:-1:-1;;;5036:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5105:17;;:21;5101:224;;5247:10;5236:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;5236:30:0;5228:85;;;;-1:-1:-1;;;5228:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1856:374;1916:4;2139:20;;1982:66;2179:15;;;;;:42;;;2210:11;2198:8;:23;;2179:42;2171:51;1856:374;-1:-1:-1;;;;1856:374:0:o

ipfs://183450e1fa31e421e43a1c89279cdf73fd640126be89f649b8ec55143e61dfc9