Contract 0xa8A0C62d1fa894432F331888Dc7B435B41b85Cdf

/**
 *Submitted for verification at snowtrace.io on 2022-07-04
*/

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

10478:6791:0:-:0;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;10478:6791:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12:1:-1;9;2:12;13510:204:0;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13510:204:0;-1:-1:-1;;;;;13510:204:0;;:::i;:::-;;;;;;;;;;;;;;;;11409:42;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11409:42:0;-1:-1:-1;;;;;11409:42:0;;:::i;12102:93::-;;;:::i;10981:41::-;;;:::i;13722:114::-;;;:::i;9320:170::-;;;:::i;:::-;;10812:86;;;:::i;:::-;;;;-1:-1:-1;;;;;10812:86:0;;;;;;;;;;;;;;14645:79;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14645:79:0;;:::i;14060:106::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;14060:106:0;;;;;;-1:-1:-1;;;;;14060:106:0;;:::i;15514:1117::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;15514:1117:0;;:::i;15094:303::-;;;:::i;8615:25::-;;;:::i;11968:122::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11968:122:0;-1:-1:-1;;;;;11968:122:0;;:::i;11579:50::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11579:50:0;-1:-1:-1;;;;;11579:50:0;;:::i;10721:84::-;;;:::i;12203:112::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12203:112:0;-1:-1:-1;;;;;12203:112:0;;:::i;11073:29::-;;;:::i;10947:27::-;;;:::i;12323:131::-;;;:::i;10911:29::-;;;:::i;14554:83::-;;;:::i;11345:57::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;11345:57:0;-1:-1:-1;;;;;11345:57:0;;:::i;13171:331::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13171:331:0;-1:-1:-1;;;;;13171:331:0;;:::i;9080:117::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;9080:117:0;-1:-1:-1;;;;;9080:117:0;;:::i;13959:89::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13959:89:0;;:::i;11109:29::-;;;:::i;12462:331::-;;;:::i;12805:354::-;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;12805:354:0;-1:-1:-1;;;;;12805:354:0;;:::i;11495:25::-;;;:::i;13848:99::-;;;:::i;11145:35::-;;;:::i;15405:97::-;;;:::i;11035:31::-;;;:::i;10630:84::-;;;:::i;8647:32::-;;;:::i;13510:204::-;-1:-1:-1;;;;;13689:16:0;;13564:7;13689:16;;;:7;:16;;;;;;;;;13641:22;:31;;;;;;13591:115;;13689:16;13591:93;;13679:4;;13591:83;;13620:53;;:16;:14;:16::i;:::-;:20;:53;:20;:53;:::i;:::-;-1:-1:-1;;;;;13591:24:0;;;;;;:15;:24;;;;;;;:28;:83::i;:::-;:87;:93;:87;:93;:::i;:::-;:97;:115;:97;:115;:::i;:::-;13584:122;13510:204;-1:-1:-1;;13510:204:0:o;11409:42::-;;;;;;;;;;;;;:::o;12102:93::-;12175:12;;12102:93;;:::o;10981:41::-;11016:6;10981:41;:::o;13722:114::-;13804:10;;13777:7;;13804:24;;11016:6;13804:24;:14;:24;:::i;:::-;13797:31;;13722:114;:::o;9320:170::-;9390:17;;-1:-1:-1;;;;;9390:17:0;9376:10;:31;9368:73;;;;;-1:-1:-1;;;9368:73:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9465:17;;;9452:30;;-1:-1:-1;;;;;;9452:30:0;-1:-1:-1;;;;;9465:17:0;;;9452:30;;;;;;9320:170::o;10812:86::-;10855:42;10812:86;:::o;14645:79::-;14699:17;14709:6;14699:9;:17::i;:::-;14645:79;:::o;14060:106::-;14133:25;14142:6;14150:7;14133:8;:25::i;:::-;14060:106;;:::o;15514:1117::-;11254:12;;-1:-1:-1;;;;;11254:12:0;11240:10;:26;11232:81;;;;-1:-1:-1;;;11232:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15605:1:::1;16712:16;:14;:16::i;:::-;16689:20;:39:::0;16756:26:::1;:24;:26::i;:::-;16739:14;:43:::0;-1:-1:-1;;;;;16797:21:0;::::1;::::0;16793:157:::1;;16854:15;16861:7;16854:6;:15::i;:::-;-1:-1:-1::0;;;;;16835:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;16918:20:::1;::::0;16884:22:::1;:31:::0;;;;;;:54;16793:157:::1;15646:12:::2;::::0;15620:62:::2;::::0;10671:42:::2;::::0;-1:-1:-1;;;;;15646:12:0::2;15668:4;15675:6:::0;15620:25:::2;:62::i;:::-;15716:12;;15697:15;:31;15693:304;;15758:20;:6:::0;11016::::2;15758:20;:10;:20;:::i;:::-;15745:10;:33:::0;15693:304:::2;;;15831:12;::::0;15811:17:::2;::::0;15831:33:::2;::::0;15848:15:::2;15831:33;:16;:33;:::i;:::-;15811:53;;15879:16;15898:25;15912:10;;15898:9;:13;;:25;;;;:::i;:::-;15879:44:::0;-1:-1:-1;15951:34:0::2;11016:6;15951:20;:6:::0;15879:44;15951:20:::2;:10;:20;:::i;:34::-;15938:10;:47:::0;-1:-1:-1;;15693:304:0::2;16372:33;::::0;;-1:-1:-1;;;16372:33:0;;16399:4:::2;16372:33;::::0;::::2;::::0;;;-1:-1:-1;;10671:42:0::2;::::0;-1:-1:-1;;16372:33:0;;;;;::::2;::::0;;;;;;;;;10671:42;16372:33;::::2;;2:2:-1::0;::::2;;;27:1;24::::0;17:12:::2;2:2;16372:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39::::0;24:38:::2;77:16;74:1;67:27;5:2;16372:33:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28::::0;21:12:::2;4:2;-1:-1:::0;16372:33:0;;-1:-1:-1;16438:21:0::2;16372:33:::0;11016:6:::2;16438:21;:11;:21;:::i;:::-;16424:10;;:35;;16416:72;;;::::0;;-1:-1:-1;;;16416:72:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;::::2;::::0;;;;;;;;;;;;;::::2;;16518:15;16501:14;:32:::0;;;16559:29:::2;::::0;11016:6:::2;16559:29;:19;:29;:::i;:::-;16544:12;:44:::0;16604:19:::2;::::0;;;;;;;::::2;::::0;;;;::::2;::::0;;::::2;-1:-1:-1::0;;;;;;16976:21:0;::::1;::::0;16972:67:::1;;17014:13;17019:7;17014:4;:13::i;15094:303::-:0;7563:1;8167:7;;:19;;8159:63;;;;;-1:-1:-1;;;8159:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7563:1;8300:7;:18;15148:10:::1;16712:16;:14;:16::i;:::-;16689:20;:39:::0;16756:26:::1;:24;:26::i;:::-;16739:14;:43:::0;-1:-1:-1;;;;;16797:21:0;::::1;::::0;16793:157:::1;;16854:15;16861:7;16854:6;:15::i;:::-;-1:-1:-1::0;;;;;16835:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;16918:20:::1;::::0;16884:22:::1;:31:::0;;;;;;:54;16793:157:::1;15196:10:::2;15171:14;15188:19:::0;;;:7:::2;:19;::::0;;;;;15222:10;;15218:172:::2;;15257:10;15271:1;15249:19:::0;;;:7:::2;:19;::::0;;;;:23;15287:41:::2;::::0;10671:42:::2;::::0;15321:6;15287:41:::2;:21;:41;:::i;:::-;15348:30;::::0;;;;;;;15359:10:::2;::::0;15348:30:::2;::::0;;;;;::::2;::::0;;::::2;15218:172;-1:-1:-1::0;;;;;;16976:21:0;::::1;::::0;16972:67:::1;;17014:13;17019:7;17014:4;:13::i;:::-;-1:-1:-1::0;7519:1:0;8479:7;:22;15094:303::o;8615:25::-;;;-1:-1:-1;;;;;8615:25:0;;:::o;11968:122::-;8845:10;;-1:-1:-1;;;;;8845:10:0;8831;:24;8823:68;;;;;-1:-1:-1;;;8823:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;12054:12:::1;:28:::0;;-1:-1:-1;;;;;;12054:28:0::1;-1:-1:-1::0;;;;;12054:28:0;;;::::1;::::0;;;::::1;::::0;;11968:122::o;11579:50::-;;;;;;;;;;;;;:::o;10721:84::-;10762:42;10721:84;:::o;12203:112::-;-1:-1:-1;;;;;12289:18:0;12262:7;12289:18;;;:9;:18;;;;;;;12203:112::o;11073:29::-;;;;:::o;10947:27::-;;;-1:-1:-1;;;;;10947:27:0;;:::o;12323:131::-;12380:7;12407:39;12416:15;12433:12;;12407:8;:39::i;10911:29::-;;;:::o;14554:83::-;14617:10;14607:21;;;;:9;:21;;;;;;14597:32;;:9;:32::i;:::-;14554:83::o;11345:57::-;;;;;;;;;;;;;:::o;13171:331::-;-1:-1:-1;;;;;13243:24:0;;13220:20;13243:24;;;:15;:24;;;;;;13294:13;;:34;;13243:24;13294:17;:34::i;:::-;13278:13;:50;13357:23;13372:7;13357:14;:23::i;:::-;-1:-1:-1;;;;;13391:24:0;;;;;;:15;:24;;;;;:42;;;13460:13;;13391:42;;-1:-1:-1;13460:34:0;;13391:42;13460:17;:34::i;:::-;13444:13;:50;-1:-1:-1;;13171:331:0:o;9080:117::-;8845:10;;-1:-1:-1;;;;;8845:10:0;8831;:24;8823:68;;;;;-1:-1:-1;;;8823:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9158:17:::1;:31:::0;;-1:-1:-1;;;;;;9158:31:0::1;-1:-1:-1::0;;;;;9158:31:0;;;::::1;::::0;;;::::1;::::0;;9080:117::o;13959:89::-;14012:28;14021:6;14029:10;14012:8;:28::i;11109:29::-;;;;:::o;12462:331::-;12509:7;12533:12;;12549:1;12533:17;12529:77;;;-1:-1:-1;12574:20:0;;12567:27;;12529:77;12636:149;12679:91;12756:13;;12679:72;12746:4;12679:62;12730:10;;12679:46;12710:14;;12679:26;:24;:26::i;:46::-;:50;:62;:50;:62;:::i;:91::-;12636:20;;;:149;:24;:149;:::i;12805:354::-;-1:-1:-1;;;;;12900:18:0;;12867:4;12900:18;;;:9;:18;;;;;;12867:4;12945:25;12966:3;12945:16;12900:18;12958:2;12945:12;:16::i;:25::-;12929:41;;12981:14;12998:92;13086:3;12998:83;13078:2;12999:73;10762:42;-1:-1:-1;;;;;13049:20:0;;:22;;;;;;;;;;;;;;;;;;;;;;5:9:-1;2:2;;;27:1;24;17:12;2:2;13049:22:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13049:22:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13049:22:0;13016:27;;;-1:-1:-1;;;13016:27:0;;-1:-1:-1;;;;;13016:27:0;;;;;;;;12999:45;;10762:42;;-1:-1:-1;;13016:27:0;;;;;13049:22;;13016:27;;;;;;;;10762:42;13016:27;;;2:2:-1;;;;27:1;24;17:12;2:2;13016:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13016:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13016:27:0;12999:12;;;:45;:16;:45;:::i;12998:92::-;12981:109;-1:-1:-1;13108:43:0;13117:23;:8;12981:109;13117:23;:12;:23;:::i;:::-;13142:8;13108;:43::i;:::-;13101:50;12805:354;-1:-1:-1;;;;;12805:354:0:o;11495:25::-;;;;:::o;13848:99::-;13899:27;;;-1:-1:-1;;;13899:27:0;;13915:10;13899:27;;;;;;13890:49;;13899:5;-1:-1:-1;;;;;13899:15:0;;-1:-1:-1;;13899:27:0;;;;;;;;;;;;;;;:15;:27;;;2:2:-1;;;;27:1;24;17:12;2:2;13899:27:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;13899:27:0;;;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;13899:27:0;13928:10;13890:8;:49::i;11145:35::-;;;;:::o;15405:97::-;15460:10;15450:21;;;;:9;:21;;;;;;15440:32;;:9;:32::i;:::-;15483:11;:9;:11::i;11035:31::-;;;;:::o;10630:84::-;10671:42;10630:84;:::o;8647:32::-;;;-1:-1:-1;;;;;8647:32:0;;:::o;434:103::-;486:4;510:19;514:1;517;510:19;;;;;;;;;;;;;-1:-1:-1;;;510:19:0;;;:3;:19::i;:::-;503:26;434:103;-1:-1:-1;;;434:103:0:o;729:432::-;781:4;1023:6;1019:47;;-1:-1:-1;1053:1:0;1046:8;;1019:47;1087:5;;;1091:1;1087;:5;:1;1111:5;;;;;:10;1103:29;;;;;-1:-1:-1;;;1103:29:0;;;;;;;;;;;;-1:-1:-1;;;1103:29:0;;;;;;;;;;;;;;1416:103;1468:4;1492:19;1496:1;1499;1492:19;;;;;;;;;;;;;-1:-1:-1;;;1492:19:0;;;:3;:19::i;94:148::-;146:4;172:5;;;196:6;;;;188:25;;;;;-1:-1:-1;;;188:25:0;;;;;;;;;;;;-1:-1:-1;;;188:25:0;;;;;;;;;;;;;;14736:350;7563:1;8167:7;;:19;;8159:63;;;;;-1:-1:-1;;;8159:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7563:1;8300:7;:18;14803:10:::1;16712:16;:14;:16::i;:::-;16689:20;:39:::0;16756:26:::1;:24;:26::i;:::-;16739:14;:43:::0;-1:-1:-1;;;;;16797:21:0;::::1;::::0;16793:157:::1;;16854:15;16861:7;16854:6;:15::i;:::-;-1:-1:-1::0;;;;;16835:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;16918:20:::1;::::0;16884:22:::1;:31:::0;;;;;;:54;16793:157:::1;14843:1:::2;14834:6;:10;14826:40;;;::::0;;-1:-1:-1;;;14826:40:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;14826:40:0;;;;;;;;;;;;;::::2;;14892:12;::::0;:24:::2;::::0;14909:6;14892:24:::2;:16;:24;:::i;:::-;14877:12;:39:::0;14961:10:::2;14951:21;::::0;;;:9:::2;:21;::::0;;;;;:33:::2;::::0;14977:6;14951:33:::2;:25;:33;:::i;:::-;14937:10;14927:21;::::0;;;:9:::2;:21;::::0;;;;:57;;;;14995:38:::2;::::0;-1:-1:-1;;;;;14995:5:0::2;:18;::::0;15026:6;14995:18:::2;:38::i;:::-;15049:29;::::0;;;;;;;15059:10:::2;::::0;15049:29:::2;::::0;;;;;::::2;::::0;;::::2;-1:-1:-1::0;;;;;16976:21:0;::::1;::::0;16972:67:::1;;17014:13;17019:7;17014:4;:13::i;:::-;-1:-1:-1::0;;7519:1:0;8479:7;:22;14736:350::o;14178:364::-;7563:1;8167:7;;:19;;8159:63;;;;;-1:-1:-1;;;8159:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;7563:1;8300:7;:18;14261:7;16712:16:::1;:14;:16::i;:::-;16689:20;:39:::0;16756:26:::1;:24;:26::i;:::-;16739:14;:43:::0;-1:-1:-1;;;;;16797:21:0;::::1;::::0;16793:157:::1;;16854:15;16861:7;16854:6;:15::i;:::-;-1:-1:-1::0;;;;;16835:16:0;::::1;;::::0;;;:7:::1;:16;::::0;;;;;;;:34;;;;16918:20:::1;::::0;16884:22:::1;:31:::0;;;;;;:54;16793:157:::1;14298:1:::2;14289:6;:10;14281:37;;;::::0;;-1:-1:-1;;;14281:37:0;;::::2;;::::0;::::2;::::0;::::2;::::0;;;;-1:-1:-1;;;14281:37:0;;;;;;;;;;;;;::::2;;14344:12;::::0;:24:::2;::::0;14361:6;14344:24:::2;:16;:24;:::i;:::-;14329:12;:39:::0;-1:-1:-1;;;;;14400:18:0;::::2;;::::0;;;:9:::2;:18;::::0;;;;;:30:::2;::::0;14423:6;14400:22:::2;:30::i;:::-;-1:-1:-1::0;;;;;14379:18:0;::::2;;::::0;;;:9:::2;:18;::::0;;;;;;;;:51;;;;14446:23;;;;;;;14379:18;;14446:23:::2;::::0;;;;;;;::::2;14480:54;:5;-1:-1:-1::0;;;;;14480:22:0::2;14503:7:::0;14520:4:::2;14527:6:::0;14480:22:::2;:54::i;:::-;-1:-1:-1::0;;;;;16976:21:0;::::1;::::0;16972:67:::1;;17014:13;17019:7;17014:4;:13::i;:::-;-1:-1:-1::0;;7519:1:0;8479:7;:22;-1:-1:-1;14178:364:0:o;3416:204::-;3543:68;;;-1:-1:-1;;;;;3543:68:0;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;3543:68:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;3517:95:0;;3536:5;;3517:18;:95::i;:::-;3416:204;;;;:::o;3232:176::-;3341:58;;;-1:-1:-1;;;;;3341:58:0;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;3341:58:0;;;;;;;;25:18:-1;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;3315:85:0;;3334:5;;3315:18;:85::i;:::-;3232:176;;;:::o;5487:106::-;5545:7;5576:1;5572;:5;:13;;5584:1;5572:13;;;-1:-1:-1;5580:1:0;;5487:106;-1:-1:-1;5487:106:0:o;543:180::-;623:4;656:12;648:6;;;;640:29;;;;-1:-1:-1;;;640: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;640:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;689:5:0;;;543:180::o;1525:179::-;1605:4;1637:12;1630:5;1622:28;;;;-1:-1:-1;;;1622:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;27:10;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1622:28:0;;1661:6;1674:1;1670;:5;;;;;;;1525:179;-1:-1:-1;;;;;1525:179:0:o;4612:598::-;4700:27;-1:-1:-1;;;;;4700:25:0;;;:27::i;:::-;4692:71;;;;;-1:-1:-1;;;4692:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;4837:12;4851:23;4886:5;-1:-1:-1;;;;;4878:19:0;4898:4;4878: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;;;4878: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;;4836:67:0;;;;4922:7;4914:52;;;;;-1:-1:-1;;;4914:52:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4983:17;;:21;4979:224;;5125:10;5114:30;;;;;15:2:-1;10:3;7:11;4:2;;;31:1;28;21:12;4:2;-1:-1;5114:30:0;5106:85;;;;-1:-1:-1;;;5106:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1734:374;1794:4;2017:20;;1860:66;2057:15;;;;;:42;;;2088:11;2076:8;:23;;2057:42;2049:51;1734:374;-1:-1:-1;;;;1734:374:0:o

ipfs://183450e1fa31e421e43a1c89279cdf73fd640126be89f649b8ec55143e61dfc9