Contract 0x6914Cd86BDf0b46f7257Bc0E0a994174d5fD6C27

/**
 *Submitted for verification at snowtrace.io on 2021-12-02
*/

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

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

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

0000000000000000000000005fb4d08bCBD444fDD5a0545fdB0C86783D186382000000000000000000000000c9a51fb9057380494262fd291aed74317332c0a2

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

-----Encoded View---------------
2 Constructor Arguments found :
Arg [0] : 0000000000000000000000005fb4d08bCBD444fDD5a0545fdB0C86783D186382
Arg [1] : 000000000000000000000000c9a51fb9057380494262fd291aed74317332c0a2

10671:6791:0:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;10671:6791:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;13703:204:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13703:204:0;-1:-1:-1;;;;;13703:204:0;;:::i;:::-;;;;;;;;;;;;;;;;11602:42;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11602:42:0;-1:-1:-1;;;;;11602:42:0;;:::i;12295:93::-;;;:::i;11174:41::-;;;:::i;13915:114::-;;;:::i;9513:170::-;;;:::i;:::-;;11005:86;;;:::i;:::-;;;;-1:-1:-1;;;;;11005:86:0;;;;;;;;;;;;;;14838:79;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14838:79:0;;:::i;14253:106::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14253:106:0;;;;;;-1:-1:-1;;;;;14253:106:0;;:::i;15707:1117::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;15707:1117:0;;:::i;15287:303::-;;;:::i;8808:25::-;;;:::i;12161:122::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12161:122:0;-1:-1:-1;;;;;12161:122:0;;:::i;11772:50::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11772:50:0;-1:-1:-1;;;;;11772:50:0;;:::i;10914:84::-;;;:::i;12396:112::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12396:112:0;-1:-1:-1;;;;;12396:112:0;;:::i;11266:29::-;;;:::i;11140:27::-;;;:::i;12516:131::-;;;:::i;11104:29::-;;;:::i;14747:83::-;;;:::i;11538:57::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11538:57:0;-1:-1:-1;;;;;11538:57:0;;:::i;13364:331::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13364:331:0;-1:-1:-1;;;;;13364:331:0;;:::i;9273:117::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;9273:117:0;-1:-1:-1;;;;;9273:117:0;;:::i;14152:89::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14152:89:0;;:::i;11302:29::-;;;:::i;12655:331::-;;;:::i;12998:354::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12998:354:0;-1:-1:-1;;;;;12998:354:0;;:::i;11688:25::-;;;:::i;14041:99::-;;;:::i;11338:35::-;;;:::i;15598:97::-;;;:::i;11228:31::-;;;:::i;10823:84::-;;;:::i;8840:32::-;;;:::i;13703:204::-;-1:-1:-1;;;;;13882:16:0;;13757:7;13882:16;;;:7;:16;;;;;;;;;13834:22;:31;;;;;;13784:115;;13882:16;13784:93;;13872:4;;13784:83;;13813:53;;:16;:14;:16::i;:::-;:20;:53;:20;:53;:::i;:::-;-1:-1:-1;;;;;13784:24:0;;;;;;:15;:24;;;;;;;:28;:83::i;:::-;:87;:93;:87;:93;:::i;:::-;:97;:115;:97;:115;:::i;:::-;13777:122;13703:204;-1:-1:-1;;13703:204:0:o;11602:42::-;;;;;;;;;;;;;:::o;12295:93::-;12368:12;;12295:93;;:::o;11174:41::-;11209:6;11174:41;:::o;13915:114::-;13997:10;;13970:7;;13997:24;;11209:6;13997:24;:14;:24;:::i;:::-;13990:31;;13915:114;:::o;9513:170::-;9583:17;;-1:-1:-1;;;;;9583:17:0;9569:10;:31;9561:73;;;;;-1:-1:-1;;;9561:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9658:17;;;9645:30;;-1:-1:-1;;;;;;9645:30:0;-1:-1:-1;;;;;9658:17:0;;;9645:30;;;;;;9513:170::o;11005:86::-;11048:42;11005:86;:::o;14838:79::-;14892:17;14902:6;14892:9;:17::i;:::-;14838:79;:::o;14253:106::-;14326:25;14335:6;14343:7;14326:8;:25::i;:::-;14253:106;;:::o;15707:1117::-;11447:12;;-1:-1:-1;;;;;11447:12:0;11433:10;:26;11425:81;;;;-1:-1:-1;;;11425:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15798:1:::1;16905:16;:14;:16::i;:::-;16882:20;:39:::0;16949:26:::1;:24;:26::i;:::-;16932:14;:43:::0;-1:-1:-1;;;;;16990:21:0;::::1;::::0;16986:157:::1;;17047:15;17054:7;17047:6;:15::i;:::-;-1:-1:-1::0;;;;;17028:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;17111:20:::1;::::0;17077:22:::1;:31:::0;;;;;;:54;16986:157:::1;15839:12:::2;::::0;15813:62:::2;::::0;10864:42:::2;::::0;-1:-1:-1;;;;;15839:12:0::2;15861:4;15868:6:::0;15813:25:::2;:62::i;:::-;15909:12;;15890:15;:31;15886:304;;15951:20;:6:::0;11209::::2;15951:20;:10;:20;:::i;:::-;15938:10;:33:::0;15886:304:::2;;;16024:12;::::0;16004:17:::2;::::0;16024:33:::2;::::0;16041:15:::2;16024:33;:16;:33;:::i;:::-;16004:53;;16072:16;16091:25;16105:10;;16091:9;:13;;:25;;;;:::i;:::-;16072:44:::0;-1:-1:-1;16144:34:0::2;11209:6;16144:20;:6:::0;16072:44;16144:20:::2;:10;:20;:::i;:34::-;16131:10;:47:::0;-1:-1:-1;;15886:304:0::2;16565:33;::::0;;-1:-1:-1;;;16565:33:0;;16592:4:::2;16565:33;::::0;::::2;::::0;;;-1:-1:-1;;10864:42:0::2;::::0;-1:-1:-1;;16565:33:0;;;;;::::2;::::0;;;;;;;;;10864:42;16565:33;::::2;;2:2:-1::0;::::2;;;27:1;24::::0;17:12:::2;2:2;16565:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::2;77:16;74:1;67:27;5:2;16565:33:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::2;4:2;-1:-1:::0;16565:33:0;;-1:-1:-1;16631:21:0::2;16565:33:::0;11209:6:::2;16631:21;:11;:21;:::i;:::-;16617:10;;:35;;16609:72;;;::::0;;-1:-1:-1;;;16609:72:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;::::2;::::0;;;;;;;;;;;;;::::2;;16711:15;16694:14;:32:::0;;;16752:29:::2;::::0;11209:6:::2;16752:29;:19;:29;:::i;:::-;16737:12;:44:::0;16797:19:::2;::::0;;;;;;;::::2;::::0;;;;::::2;::::0;;::::2;-1:-1:-1::0;;;;;;17169:21:0;::::1;::::0;17165:67:::1;;17207:13;17212:7;17207:4;:13::i;15287:303::-:0;7756:1;8360:7;;:19;;8352:63;;;;;-1:-1:-1;;;8352:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7756:1;8493:7;:18;15341:10:::1;16905:16;:14;:16::i;:::-;16882:20;:39:::0;16949:26:::1;:24;:26::i;:::-;16932:14;:43:::0;-1:-1:-1;;;;;16990:21:0;::::1;::::0;16986:157:::1;;17047:15;17054:7;17047:6;:15::i;:::-;-1:-1:-1::0;;;;;17028:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;17111:20:::1;::::0;17077:22:::1;:31:::0;;;;;;:54;16986:157:::1;15389:10:::2;15364:14;15381:19:::0;;;:7:::2;:19;::::0;;;;;15415:10;;15411:172:::2;;15450:10;15464:1;15442:19:::0;;;:7:::2;:19;::::0;;;;:23;15480:41:::2;::::0;10864:42:::2;::::0;15514:6;15480:41:::2;:21;:41;:::i;:::-;15541:30;::::0;;;;;;;15552:10:::2;::::0;15541:30:::2;::::0;;;;;::::2;::::0;;::::2;15411:172;-1:-1:-1::0;;;;;;17169:21:0;::::1;::::0;17165:67:::1;;17207:13;17212:7;17207:4;:13::i;:::-;-1:-1:-1::0;7712:1:0;8672:7;:22;15287:303::o;8808:25::-;;;-1:-1:-1;;;;;8808:25:0;;:::o;12161:122::-;9038:10;;-1:-1:-1;;;;;9038:10:0;9024;:24;9016:68;;;;;-1:-1:-1;;;9016:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12247:12:::1;:28:::0;;-1:-1:-1;;;;;;12247:28:0::1;-1:-1:-1::0;;;;;12247:28:0;;;::::1;::::0;;;::::1;::::0;;12161:122::o;11772:50::-;;;;;;;;;;;;;:::o;10914:84::-;10955:42;10914:84;:::o;12396:112::-;-1:-1:-1;;;;;12482:18:0;12455:7;12482:18;;;:9;:18;;;;;;;12396:112::o;11266:29::-;;;;:::o;11140:27::-;;;-1:-1:-1;;;;;11140:27:0;;:::o;12516:131::-;12573:7;12600:39;12609:15;12626:12;;12600:8;:39::i;11104:29::-;;;:::o;14747:83::-;14810:10;14800:21;;;;:9;:21;;;;;;14790:32;;:9;:32::i;:::-;14747:83::o;11538:57::-;;;;;;;;;;;;;:::o;13364:331::-;-1:-1:-1;;;;;13436:24:0;;13413:20;13436:24;;;:15;:24;;;;;;13487:13;;:34;;13436:24;13487:17;:34::i;:::-;13471:13;:50;13550:23;13565:7;13550:14;:23::i;:::-;-1:-1:-1;;;;;13584:24:0;;;;;;:15;:24;;;;;:42;;;13653:13;;13584:42;;-1:-1:-1;13653:34:0;;13584:42;13653:17;:34::i;:::-;13637:13;:50;-1:-1:-1;;13364:331:0:o;9273:117::-;9038:10;;-1:-1:-1;;;;;9038:10:0;9024;:24;9016:68;;;;;-1:-1:-1;;;9016:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9351:17:::1;:31:::0;;-1:-1:-1;;;;;;9351:31:0::1;-1:-1:-1::0;;;;;9351:31:0;;;::::1;::::0;;;::::1;::::0;;9273:117::o;14152:89::-;14205:28;14214:6;14222:10;14205:8;:28::i;11302:29::-;;;;:::o;12655:331::-;12702:7;12726:12;;12742:1;12726:17;12722:77;;;-1:-1:-1;12767:20:0;;12760:27;;12722:77;12829:149;12872:91;12949:13;;12872:72;12939:4;12872:62;12923:10;;12872:46;12903:14;;12872:26;:24;:26::i;:46::-;:50;:62;:50;:62;:::i;:91::-;12829:20;;;:149;:24;:149;:::i;12998:354::-;-1:-1:-1;;;;;13093:18:0;;13060:4;13093:18;;;:9;:18;;;;;;13060:4;13138:25;13159:3;13138:16;13093:18;13151:2;13138:12;:16::i;:25::-;13122:41;;13174:14;13191:92;13279:3;13191:83;13271:2;13192:73;10955:42;-1:-1:-1;;;;;13242:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;13242:22:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13242:22:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13242:22:0;13209:27;;;-1:-1:-1;;;13209:27:0;;-1:-1:-1;;;;;13209:27:0;;;;;;;;13192:45;;10955:42;;-1:-1:-1;;13209:27:0;;;;;13242:22;;13209:27;;;;;;;;10955:42;13209:27;;;2:2:-1;;;;27:1;24;17:12;2:2;13209:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13209:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13209:27:0;13192:12;;;:45;:16;:45;:::i;13191:92::-;13174:109;-1:-1:-1;13301:43:0;13310:23;:8;13174:109;13310:23;:12;:23;:::i;:::-;13335:8;13301;:43::i;:::-;13294:50;12998:354;-1:-1:-1;;;;;12998:354:0:o;11688:25::-;;;;:::o;14041:99::-;14092:27;;;-1:-1:-1;;;14092:27:0;;14108:10;14092:27;;;;;;14083:49;;14092:5;-1:-1:-1;;;;;14092:15:0;;-1:-1:-1;;14092:27:0;;;;;;;;;;;;;;;:15;:27;;;2:2:-1;;;;27:1;24;17:12;2:2;14092:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14092:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14092:27:0;14121:10;14083:8;:49::i;11338:35::-;;;;:::o;15598:97::-;15653:10;15643:21;;;;:9;:21;;;;;;15633:32;;:9;:32::i;:::-;15676:11;:9;:11::i;11228:31::-;;;;:::o;10823:84::-;10864:42;10823:84;:::o;8840:32::-;;;-1:-1:-1;;;;;8840:32:0;;:::o;627:103::-;679:4;703:19;707:1;710;703:19;;;;;;;;;;;;;-1:-1:-1;;;703:19:0;;;:3;:19::i;:::-;696:26;627:103;-1:-1:-1;;;627:103:0:o;922:432::-;974:4;1216:6;1212:47;;-1:-1:-1;1246:1:0;1239:8;;1212:47;1280:5;;;1284:1;1280;:5;:1;1304:5;;;;;:10;1296:29;;;;;-1:-1:-1;;;1296:29:0;;;;;;;;;;;;-1:-1:-1;;;1296:29:0;;;;;;;;;;;;;;1609:103;1661:4;1685:19;1689:1;1692;1685:19;;;;;;;;;;;;;-1:-1:-1;;;1685:19:0;;;:3;:19::i;287:148::-;339:4;365:5;;;389:6;;;;381:25;;;;;-1:-1:-1;;;381:25:0;;;;;;;;;;;;-1:-1:-1;;;381:25:0;;;;;;;;;;;;;;14929:350;7756:1;8360:7;;:19;;8352:63;;;;;-1:-1:-1;;;8352:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7756:1;8493:7;:18;14996:10:::1;16905:16;:14;:16::i;:::-;16882:20;:39:::0;16949:26:::1;:24;:26::i;:::-;16932:14;:43:::0;-1:-1:-1;;;;;16990:21:0;::::1;::::0;16986:157:::1;;17047:15;17054:7;17047:6;:15::i;:::-;-1:-1:-1::0;;;;;17028:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;17111:20:::1;::::0;17077:22:::1;:31:::0;;;;;;:54;16986:157:::1;15036:1:::2;15027:6;:10;15019:40;;;::::0;;-1:-1:-1;;;15019:40:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;15019:40:0;;;;;;;;;;;;;::::2;;15085:12;::::0;:24:::2;::::0;15102:6;15085:24:::2;:16;:24;:::i;:::-;15070:12;:39:::0;15154:10:::2;15144:21;::::0;;;:9:::2;:21;::::0;;;;;:33:::2;::::0;15170:6;15144:33:::2;:25;:33;:::i;:::-;15130:10;15120:21;::::0;;;:9:::2;:21;::::0;;;;:57;;;;15188:38:::2;::::0;-1:-1:-1;;;;;15188:5:0::2;:18;::::0;15219:6;15188:18:::2;:38::i;:::-;15242:29;::::0;;;;;;;15252:10:::2;::::0;15242:29:::2;::::0;;;;;::::2;::::0;;::::2;-1:-1:-1::0;;;;;17169:21:0;::::1;::::0;17165:67:::1;;17207:13;17212:7;17207:4;:13::i;:::-;-1:-1:-1::0;;7712:1:0;8672:7;:22;14929:350::o;14371:364::-;7756:1;8360:7;;:19;;8352:63;;;;;-1:-1:-1;;;8352:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7756:1;8493:7;:18;14454:7;16905:16:::1;:14;:16::i;:::-;16882:20;:39:::0;16949:26:::1;:24;:26::i;:::-;16932:14;:43:::0;-1:-1:-1;;;;;16990:21:0;::::1;::::0;16986:157:::1;;17047:15;17054:7;17047:6;:15::i;:::-;-1:-1:-1::0;;;;;17028:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;17111:20:::1;::::0;17077:22:::1;:31:::0;;;;;;:54;16986:157:::1;14491:1:::2;14482:6;:10;14474:37;;;::::0;;-1:-1:-1;;;14474:37:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;14474:37:0;;;;;;;;;;;;;::::2;;14537:12;::::0;:24:::2;::::0;14554:6;14537:24:::2;:16;:24;:::i;:::-;14522:12;:39:::0;-1:-1:-1;;;;;14593:18:0;::::2;;::::0;;;:9:::2;:18;::::0;;;;;:30:::2;::::0;14616:6;14593:22:::2;:30::i;:::-;-1:-1:-1::0;;;;;14572:18:0;::::2;;::::0;;;:9:::2;:18;::::0;;;;;;;;:51;;;;14639:23;;;;;;;14572:18;;14639:23:::2;::::0;;;;;;;::::2;14673:54;:5;-1:-1:-1::0;;;;;14673:22:0::2;14696:7:::0;14713:4:::2;14720:6:::0;14673:22:::2;:54::i;:::-;-1:-1:-1::0;;;;;17169:21:0;::::1;::::0;17165:67:::1;;17207:13;17212:7;17207:4;:13::i;:::-;-1:-1:-1::0;;7712:1:0;8672:7;:22;-1:-1:-1;14371:364:0:o;3609:204::-;3736:68;;;-1:-1:-1;;;;;3736:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;3736:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;3710:95:0;;3729:5;;3710:18;:95::i;:::-;3609:204;;;;:::o;3425:176::-;3534:58;;;-1:-1:-1;;;;;3534:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;3534:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;3508:85:0;;3527:5;;3508:18;:85::i;:::-;3425:176;;;:::o;5680:106::-;5738:7;5769:1;5765;:5;:13;;5777:1;5765:13;;;-1:-1:-1;5773:1:0;;5680:106;-1:-1:-1;5680:106:0:o;736:180::-;816:4;849:12;841:6;;;;833:29;;;;-1:-1:-1;;;833: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;833:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;882:5:0;;;736:180::o;1718:179::-;1798:4;1830:12;1823:5;1815:28;;;;-1:-1:-1;;;1815:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27:10;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1815:28:0;;1854:6;1867:1;1863;:5;;;;;;;1718:179;-1:-1:-1;;;;;1718:179:0:o;4805:598::-;4893:27;-1:-1:-1;;;;;4893:25:0;;;:27::i;:::-;4885:71;;;;;-1:-1:-1;;;4885:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;5030:12;5044:23;5079:5;-1:-1:-1;;;;;5071:19:0;5091:4;5071: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;;;5071: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;;5029:67:0;;;;5115:7;5107:52;;;;;-1:-1:-1;;;5107:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5176:17;;:21;5172:224;;5318:10;5307:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;5307:30:0;5299:85;;;;-1:-1:-1;;;5299:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1927:374;1987:4;2210:20;;2053:66;2250:15;;;;;:42;;;2281:11;2269:8;:23;;2250:42;2242:51;1927:374;-1:-1:-1;;;;1927:374:0:o

ipfs://183450e1fa31e421e43a1c89279cdf73fd640126be89f649b8ec55143e61dfc9