Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at basescan.org on 2023-08-02
*/

// SPDX-License-Identifier: MIT
pragma solidity 0.8.13;


// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)



/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @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.
        return (a & b) + (a ^ b) / 2;
    }

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
     * with further edits by Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + prod0.
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1, "Math: mulDiv overflow");

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
            // See https://cs.stackexchange.com/q/138556/92363.

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
            // in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        uint256 result = mulDiv(x, y, denominator);
        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}



interface IMinter {
    function update_period() external returns (uint);
}


interface IRewardsDistributor {
    function checkpoint_token() external;
    function checkpoint_total_supply() external;
}


interface IFlow {
    function totalSupply() external view returns (uint);
    function balanceOf(address) external view returns (uint);
    function approve(address spender, uint value) external returns (bool);
    function transfer(address, uint) external returns (bool);
    function transferFrom(address,address,uint) external returns (bool);
    function mint(address, uint) external returns (bool);
    function minter() external returns (address);
}



interface IVoter {
    function _ve() external view returns (address);
    function governor() external view returns (address);
    function emergencyCouncil() external view returns (address);
    function attachTokenToGauge(uint _tokenId, address account) external;
    function detachTokenFromGauge(uint _tokenId, address account) external;
    function emitDeposit(uint _tokenId, address account, uint amount) external;
    function emitWithdraw(uint _tokenId, address account, uint amount) external;
    function isWhitelisted(address token) external view returns (bool);
    function notifyRewardAmount(uint amount) external;
    function distribute(address _gauge) external;
    function gauges(address) external view returns (address);
}



interface IVotingEscrow {

    struct Point {
        int128 bias;
        int128 slope; // # -dweight / dt
        uint256 ts;
        uint256 blk; // block
    }

    function token() external view returns (address);
    function team() external returns (address);
    function epoch() external view returns (uint);
    function point_history(uint loc) external view returns (Point memory);
    function user_point_history(uint tokenId, uint loc) external view returns (Point memory);
    function user_point_epoch(uint tokenId) external view returns (uint);

    function ownerOf(uint) external view returns (address);
    function isApprovedOrOwner(address, uint) external view returns (bool);
    function transferFrom(address, address, uint) external;

    function voting(uint tokenId) external;
    function abstain(uint tokenId) external;
    function attach(uint tokenId) external;
    function detach(uint tokenId) external;

    function checkpoint() external;
    function deposit_for(uint tokenId, uint value) external;
    function create_lock_for(uint, uint, address) external returns (uint);

    function balanceOfNFT(uint) external view returns (uint);
    function totalSupply() external view returns (uint);
}


// codifies the minting rules as per ve(3,3), abstracted from the token to support any token that allows minting

contract Minter is IMinter {
    uint internal constant WEEK = 86400 * 7; // allows minting once per week (reset every Thursday 00:00 UTC)
    uint public EMISSION = 990;
    uint internal constant MAX_EMISSION = 6000;
    uint internal constant MIN_EMISSION = 250; // at most 1/2 of previous epoch
    uint internal constant TAIL_EMISSION = 2;
    uint internal constant PRECISION = 1000;
    IFlow public immutable _flow;
    IVoter public immutable _voter;
    IVotingEscrow public immutable _ve;
    IRewardsDistributor public immutable _rewards_distributor;
    uint public weekly = 300_000 * 1e18; // represents a starting weekly emission of 300K FLOW (FLOW has 18 decimals)
    uint public active_period;

    address internal initializer;
    address public team;
    address public pendingTeam;
    uint public teamRate;
    uint public constant MAX_TEAM_RATE = 50; // 5% max

    event Mint(address indexed sender, uint weekly, uint circulating_supply, uint circulating_emission);
    event EmissionSet(address indexed setter, uint256 emission);

    struct Claim {
        address claimant;
        uint256 amount;
        uint256 lockTime;
    }

    constructor(
        address __voter, // the voting & distribution system
        address __ve, // the ve(3,3) system that will be locked into
        address __rewards_distributor // the distribution system that ensures users aren't diluted
    ) {
        initializer = msg.sender;
        team = msg.sender;
        teamRate = 50; // 30 bps = 3%
        _flow = IFlow(IVotingEscrow(__ve).token());
        _voter = IVoter(__voter);
        _ve = IVotingEscrow(__ve);
        _rewards_distributor = IRewardsDistributor(__rewards_distributor);
        active_period = ((block.timestamp + (2 * WEEK)) / WEEK) * WEEK;
    }

    function initialMintAndLock(
        Claim[] calldata claims,
        uint max // sum amounts / max = % ownership of top protocols, so if initial 20m is distributed, and target is 25% protocol ownership, then max - 4 x 20m = 80m
    ) external {
        require(initializer == msg.sender, "not initializer");
        _flow.mint(address(this), max);
        _flow.approve(address(_ve), max);
        uint256 length = claims.length;
        for (uint i = 0; i < length;) {
            _ve.create_lock_for(claims[i].amount, claims[i].lockTime, claims[i].claimant);
            unchecked {
                ++i;
            }
        }
    }

    function startActivePeriod() external {
        require(initializer == msg.sender, "not initializer");
        initializer = address(0);
        // allow minter.update_period() to mint new emissions THIS Thursday
        active_period = ((block.timestamp) / WEEK) * WEEK;
    }

    function setTeam(address _team) external {
        require(msg.sender == team, "not team");
        pendingTeam = _team;
    }

    function acceptTeam() external {
        require(msg.sender == pendingTeam, "not pending team");
        team = pendingTeam;
    }

    function setTeamRate(uint _teamRate) external {
        require(msg.sender == team, "not team");
        require(_teamRate <= MAX_TEAM_RATE, "rate too high");
        teamRate = _teamRate;
    }

    function setEmission(uint _emission) external {
        require(msg.sender == team, "not team");
        require(_emission <= MAX_EMISSION && _emission >= MIN_EMISSION, "emission out of range");
        EMISSION = _emission;

        emit EmissionSet(msg.sender, _emission);
    }

    // calculate circulating supply as total token supply - locked supply
    function circulating_supply() public view returns (uint) {
        return _flow.totalSupply() - _ve.totalSupply();
    }

    // emission calculation is 1% of available supply to mint adjusted by circulating / total supply
    function calculate_emission() public view returns (uint) {
        return (weekly * EMISSION) / PRECISION;
    }

    // weekly emission takes the max of calculated (aka target) emission versus circulating tail end emission
    function weekly_emission() public view returns (uint) {
        return Math.max(calculate_emission(), circulating_emission());
    }

    // calculates tail end (infinity) emissions as 0.2% of total supply
    function circulating_emission() public view returns (uint) {
        return (circulating_supply() * TAIL_EMISSION) / PRECISION;
    }

    // calculate inflation and adjust ve balances accordingly
    function calculate_growth(uint _minted) public view returns (uint) {
        uint _veTotal = _ve.totalSupply();
        uint _flowTotal = _flow.totalSupply();
        return
            (((((_minted * _veTotal) / _flowTotal) * _veTotal) / _flowTotal) *
                _veTotal) /
            _flowTotal /
            2;
    }

    // update period can only be called once per cycle (1 week)
    function update_period() external returns (uint) {
        uint _period = active_period;
        if (block.timestamp >= _period + WEEK && initializer == address(0)) { // only trigger if new week
            _period = (block.timestamp / WEEK) * WEEK;
            active_period = _period;
            weekly = weekly_emission();

            uint _growth = calculate_growth(weekly);
            uint _teamEmissions = (teamRate * (_growth + weekly)) /
                (PRECISION - teamRate);
            uint _required = _growth + weekly + _teamEmissions;
            uint _balanceOf = _flow.balanceOf(address(this));
            if (_balanceOf < _required) {
                _flow.mint(address(this), _required - _balanceOf);
            }

            require(_flow.transfer(team, _teamEmissions));
            require(_flow.transfer(address(_rewards_distributor), _growth));
            _rewards_distributor.checkpoint_token(); // checkpoint token balance that was just minted in rewards distributor
            _rewards_distributor.checkpoint_total_supply(); // checkpoint supply

            _flow.approve(address(_voter), weekly);
            _voter.notifyRewardAmount(weekly);

            emit Mint(msg.sender, weekly, circulating_supply(), circulating_emission());
        }
        return _period;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"__voter","type":"address"},{"internalType":"address","name":"__ve","type":"address"},{"internalType":"address","name":"__rewards_distributor","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"setter","type":"address"},{"indexed":false,"internalType":"uint256","name":"emission","type":"uint256"}],"name":"EmissionSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":false,"internalType":"uint256","name":"weekly","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"circulating_supply","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"circulating_emission","type":"uint256"}],"name":"Mint","type":"event"},{"inputs":[],"name":"EMISSION","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_TEAM_RATE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_flow","outputs":[{"internalType":"contract IFlow","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_rewards_distributor","outputs":[{"internalType":"contract IRewardsDistributor","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_ve","outputs":[{"internalType":"contract IVotingEscrow","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_voter","outputs":[{"internalType":"contract IVoter","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptTeam","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"active_period","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"calculate_emission","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_minted","type":"uint256"}],"name":"calculate_growth","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"circulating_emission","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"circulating_supply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"components":[{"internalType":"address","name":"claimant","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"lockTime","type":"uint256"}],"internalType":"struct Minter.Claim[]","name":"claims","type":"tuple[]"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"initialMintAndLock","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pendingTeam","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_emission","type":"uint256"}],"name":"setEmission","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_team","type":"address"}],"name":"setTeam","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_teamRate","type":"uint256"}],"name":"setTeamRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startActivePeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"team","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"update_period","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"weekly","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"weekly_emission","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

000000000000000000000000ab9b68c9e53c94d7c0949fb909e80e4a29f9134a00000000000000000000000091f85d68b413de823684c891db515b0390a0251200000000000000000000000071eaf68c2a23b7bd78db4987c3ecdb41c3b3b388

-----Decoded View---------------
Arg [0] : __voter (address): 0xab9B68c9e53c94D7c0949FB909E80e4a29F9134A
Arg [1] : __ve (address): 0x91F85d68B413dE823684c891db515B0390a02512
Arg [2] : __rewards_distributor (address): 0x71Eaf68c2A23b7Bd78Db4987c3eCdB41c3b3b388

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 000000000000000000000000ab9b68c9e53c94d7c0949fb909e80e4a29f9134a
Arg [1] : 00000000000000000000000091f85d68b413de823684c891db515b0390a02512
Arg [2] : 00000000000000000000000071eaf68c2a23b7bd78db4987c3ecdb41c3b3b388

15971:6269:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16823:39;;16860:2;16823:39;;;;;160:25:1;;;148:2;133:18;16823:39:0;;;;;;;;18754:129;;;;;;:::i;:::-;;:::i;:::-;;20287:135;;;:::i;16549:35::-;;;;;;19032:198;;;;;;:::i;:::-;;:::i;19839:114::-;;;:::i;16407:30::-;;;;;;;;-1:-1:-1;;;;;851:32:1;;;833:51;;821:2;806:18;16407:30:0;672:218:1;17806:650:0;;;;;;:::i;:::-;;:::i;16485:57::-;;;;;16763:26;;;;;-1:-1:-1;;;;;16763:26:0;;;16796:20;;;;;;18464:282;;;:::i;16737:19::-;;;;;-1:-1:-1;;;;;16737:19:0;;;16444:34;;;;;20493:334;;;;;;:::i;:::-;;:::i;16116:26::-;;;;;;18891:133;;;:::i;20072:134::-;;;:::i;16668:25::-;;;;;;19238:286;;;;;;:::i;:::-;;:::i;19607:122::-;;;:::i;20900:1337::-;;;:::i;16372:28::-;;;;;18754:129;18828:4;;-1:-1:-1;;;;;18828:4:0;18814:10;:18;18806:39;;;;-1:-1:-1;;;18806:39:0;;;;;;;:::i;:::-;;;;;;;;;18856:11;:19;;-1:-1:-1;;;;;;18856:19:0;-1:-1:-1;;;;;18856:19:0;;;;;;;;;;18754:129::o;20287:135::-;20340:4;16361;16318:1;20365:20;:18;:20::i;:::-;:36;;;;:::i;:::-;20364:50;;;;:::i;:::-;20357:57;;20287:135;:::o;19032:198::-;19111:4;;-1:-1:-1;;;;;19111:4:0;19097:10;:18;19089:39;;;;-1:-1:-1;;;19089:39:0;;;;;;;:::i;:::-;16860:2;19147:9;:26;;19139:52;;;;-1:-1:-1;;;19139:52:0;;3576:2:1;19139:52:0;;;3558:21:1;3615:2;3595:18;;;3588:30;-1:-1:-1;;;3634:18:1;;;3627:43;3687:18;;19139:52:0;3374:337:1;19139:52:0;19202:8;:20;19032:198::o;19839:114::-;19890:4;16361;19924:8;;19915:6;;:17;;;;:::i;17806:650::-;18072:11;;-1:-1:-1;;;;;18072:11:0;18087:10;18072:25;18064:53;;;;-1:-1:-1;;;18064:53:0;;3918:2:1;18064:53:0;;;3900:21:1;3957:2;3937:18;;;3930:30;-1:-1:-1;;;3976:18:1;;;3969:45;4031:18;;18064:53:0;3716:339:1;18064:53:0;18128:30;;-1:-1:-1;;;18128:30:0;;18147:4;18128:30;;;4234:51:1;4301:18;;;4294:34;;;18128:5:0;-1:-1:-1;;;;;18128:10:0;;;;4207:18:1;;18128:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;18169:32:0;;-1:-1:-1;;;18169:32:0;;-1:-1:-1;;;;;18191:3:0;4252:32:1;;18169::0;;;4234:51:1;4301:18;;;4294:34;;;18169:5:0;:13;;;;4207:18:1;;18169:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;18229:6:0;18212:14;18253:196;18274:6;18270:1;:10;18253:196;;;18298:3;-1:-1:-1;;;;;18298:19:0;;18318:6;;18325:1;18318:9;;;;;;;:::i;:::-;;;;;;:16;;;18336:6;;18343:1;18336:9;;;;;;;:::i;:::-;;;;;;:18;;;18356:6;;18363:1;18356:9;;;;;;;:::i;:::-;:18;;;:9;;;;;:18;;;;-1:-1:-1;18356:18:0;:::i;:::-;18298:77;;-1:-1:-1;;;;;;18298:77:0;;;;;;;;;;4955:25:1;;;;4996:18;;;4989:34;;;;-1:-1:-1;;;;;5059:32:1;5039:18;;;5032:60;4928:18;;18298:77:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;18419:3:0;;18253:196;;;;18053:403;17806:650;;;:::o;18464:282::-;18521:11;;-1:-1:-1;;;;;18521:11:0;18536:10;18521:25;18513:53;;;;-1:-1:-1;;;18513:53:0;;3918:2:1;18513:53:0;;;3900:21:1;3957:2;3937:18;;;3930:30;-1:-1:-1;;;3976:18:1;;;3969:45;4031:18;;18513:53:0;3716:339:1;18513:53:0;18577:11;:24;;-1:-1:-1;;;;;;18577:24:0;;;16035:9;18706:24;16035:9;18707:15;18706:24;:::i;:::-;18705:33;;;;:::i;:::-;18689:13;:49;18464:282::o;20493:334::-;20554:4;20571:13;20587:3;-1:-1:-1;;;;;20587:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20571:33;;20615:15;20633:5;-1:-1:-1;;;;;20633:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;20615:37;-1:-1:-1;20818:1:0;20615:37;20767:8;20615:37;20767:8;20615:37;20688:18;20767:8;20688:7;:18;:::i;:::-;20687:33;;;;:::i;:::-;20686:46;;;;:::i;:::-;20685:61;;;;:::i;:::-;20684:91;;;;:::i;:::-;20683:119;;;;:::i;:::-;:136;;;;:::i;:::-;20663:156;20493:334;-1:-1:-1;;;;20493:334:0:o;18891:133::-;18955:11;;-1:-1:-1;;;;;18955:11:0;18941:10;:25;18933:54;;;;-1:-1:-1;;;18933:54:0;;5494:2:1;18933:54:0;;;5476:21:1;5533:2;5513:18;;;5506:30;-1:-1:-1;;;5552:18:1;;;5545:46;5608:18;;18933:54:0;5292:340:1;18933:54:0;19005:11;;18998:4;:18;;-1:-1:-1;;;;;;18998:18:0;-1:-1:-1;;;;;19005:11:0;;;18998:18;;;;;;18891:133::o;20072:134::-;20120:4;20144:54;20153:20;:18;:20::i;:::-;20175:22;:20;:22::i;:::-;20144:8;:54::i;19238:286::-;19317:4;;-1:-1:-1;;;;;19317:4:0;19303:10;:18;19295:39;;;;-1:-1:-1;;;19295:39:0;;;;;;;:::i;:::-;16187:4;19353:9;:25;;:54;;;;;16236:3;19382:9;:25;;19353:54;19345:88;;;;-1:-1:-1;;;19345:88:0;;5839:2:1;19345:88:0;;;5821:21:1;5878:2;5858:18;;;5851:30;-1:-1:-1;;;5897:18:1;;;5890:51;5958:18;;19345:88:0;5637:345:1;19345:88:0;19444:8;:20;;;19482:34;;160:25:1;;;19494:10:0;;19482:34;;148:2:1;133:18;19482:34:0;;;;;;;19238:286;:::o;19607:122::-;19658:4;19704:3;-1:-1:-1;;;;;19704:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;19682:5;-1:-1:-1;;;;;19682:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:39;;;;:::i;20900:1337::-;20975:13;;20943:4;;21022:14;16035:9;20975:13;21022:14;:::i;:::-;21003:15;:33;;:62;;;;-1:-1:-1;21040:11:0;;-1:-1:-1;;;;;21040:11:0;:25;21003:62;20999:1206;;;16035:9;21121:22;16035:9;21121:15;:22;:::i;:::-;21120:31;;;;:::i;:::-;21166:13;:23;;;21110:41;-1:-1:-1;21213:17:0;:15;:17::i;:::-;21204:6;:26;;;21247:12;;21262:24;;:16;:24::i;:::-;21247:39;;21301:19;21387:8;;16361:4;21375:20;;;;:::i;:::-;21346:6;;21336:16;;:7;:16;:::i;:::-;21324:8;;:29;;;;:::i;:::-;21323:73;;;;:::i;:::-;21301:95;;21411:14;21447;21438:6;;21428:7;:16;;;;:::i;:::-;:33;;;;:::i;:::-;21494:30;;-1:-1:-1;;;21494:30:0;;21518:4;21494:30;;;833:51:1;21411:50:0;;-1:-1:-1;21476:15:0;;-1:-1:-1;;;;;21494:5:0;:15;;;;806:18:1;;21494:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21476:48;;21556:9;21543:10;:22;21539:112;;;-1:-1:-1;;;;;21586:5:0;:10;;21605:4;21612:22;21624:10;21612:9;:22;:::i;:::-;21586:49;;-1:-1:-1;;;;;;21586:49:0;;;;;;;-1:-1:-1;;;;;4252:32:1;;;21586:49:0;;;4234:51:1;4301:18;;;4294:34;4207:18;;21586:49:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;21539:112;21690:4;;;21675:36;;-1:-1:-1;;;21675:36:0;;-1:-1:-1;;;;;21690:4:0;;;21675:36;;;4234:51:1;;;;4301:18;;;4294:34;;;21675:5:0;:14;;;;4207:18:1;;21675:36:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21667:45;;;;;;21735:54;;-1:-1:-1;;;21735:54:0;;-1:-1:-1;;;;;21758:20:0;4252:32:1;;21735:54:0;;;4234:51:1;4301:18;;;4294:34;;;21735:5:0;:14;;;;4207:18:1;;21735:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;21727:63;;;;;;21805:20;-1:-1:-1;;;;;21805:37:0;;:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21931:20;-1:-1:-1;;;;;21931:44:0;;:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;22046:6:0;;22015:38;;-1:-1:-1;;;22015:38:0;;-1:-1:-1;;;;;22015:5:0;:13;;-1:-1:-1;22015:13:0;;-1:-1:-1;22015:38:0;;22037:6;;22015:38;;-1:-1:-1;;;;;4252:32:1;;;;4234:51;;4316:2;4301:18;;4294:34;4222:2;4207:18;;4060:274;22015:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;22094:6:0;;22068:33;;-1:-1:-1;;;22068:33:0;;;;;160:25:1;;;;22068:6:0;-1:-1:-1;;;;;22068:25:0;;;;133:18:1;;22068:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22128:10;-1:-1:-1;;;;;22123:70:0;;22140:6;;22148:20;:18;:20::i;:::-;22170:22;:20;:22::i;:::-;22123:70;;;6452:25:1;;;6508:2;6493:18;;6486:34;;;;6536:18;;;6529:34;6440:2;6425:18;22123:70:0;;;;;;;21067:1138;;;;20999:1206;22222:7;20900:1337;-1:-1:-1;20900:1337:0:o;437:106::-;495:7;526:1;522;:5;:13;;534:1;522:13;;;530:1;522:13;515:20;437:106;-1:-1:-1;;;437:106:0:o;196:286:1:-;255:6;308:2;296:9;287:7;283:23;279:32;276:52;;;324:1;321;314:12;276:52;350:23;;-1:-1:-1;;;;;402:31:1;;392:42;;382:70;;448:1;445;438:12;487:180;546:6;599:2;587:9;578:7;574:23;570:32;567:52;;;615:1;612;605:12;567:52;-1:-1:-1;638:23:1;;487:180;-1:-1:-1;487:180:1:o;895:717::-;1015:6;1023;1031;1084:2;1072:9;1063:7;1059:23;1055:32;1052:52;;;1100:1;1097;1090:12;1052:52;1140:9;1127:23;1169:18;1210:2;1202:6;1199:14;1196:34;;;1226:1;1223;1216:12;1196:34;1264:6;1253:9;1249:22;1239:32;;1309:7;1302:4;1298:2;1294:13;1290:27;1280:55;;1331:1;1328;1321:12;1280:55;1371:2;1358:16;1397:2;1389:6;1386:14;1383:34;;;1413:1;1410;1403:12;1383:34;1471:7;1464:4;1456;1448:6;1444:17;1440:2;1436:26;1432:37;1429:50;1426:70;;;1492:1;1489;1482:12;1426:70;1523:4;1515:13;;;;1547:6;;-1:-1:-1;1585:20:1;;;;1572:34;;895:717;-1:-1:-1;;;;895:717:1:o;2511:331::-;2713:2;2695:21;;;2752:1;2732:18;;;2725:29;-1:-1:-1;;;2785:2:1;2770:18;;2763:38;2833:2;2818:18;;2511:331::o;2847:127::-;2908:10;2903:3;2899:20;2896:1;2889:31;2939:4;2936:1;2929:15;2963:4;2960:1;2953:15;2979:168;3019:7;3085:1;3081;3077:6;3073:14;3070:1;3067:21;3062:1;3055:9;3048:17;3044:45;3041:71;;;3092:18;;:::i;:::-;-1:-1:-1;3132:9:1;;2979:168::o;3152:217::-;3192:1;3218;3208:132;;3262:10;3257:3;3253:20;3250:1;3243:31;3297:4;3294:1;3287:15;3325:4;3322:1;3315:15;3208:132;-1:-1:-1;3354:9:1;;3152:217::o;4339:277::-;4406:6;4459:2;4447:9;4438:7;4434:23;4430:32;4427:52;;;4475:1;4472;4465:12;4427:52;4507:9;4501:16;4560:5;4553:13;4546:21;4539:5;4536:32;4526:60;;4582:1;4579;4572:12;4621:127;4682:10;4677:3;4673:20;4670:1;4663:31;4713:4;4710:1;4703:15;4737:4;4734:1;4727:15;5103:184;5173:6;5226:2;5214:9;5205:7;5201:23;5197:32;5194:52;;;5242:1;5239;5232:12;5194:52;-1:-1:-1;5265:16:1;;5103:184;-1:-1:-1;5103:184:1:o;5987:125::-;6027:4;6055:1;6052;6049:8;6046:34;;;6060:18;;:::i;:::-;-1:-1:-1;6097:9:1;;5987:125::o;6117:128::-;6157:3;6188:1;6184:6;6181:1;6178:13;6175:39;;;6194:18;;:::i;:::-;-1:-1:-1;6230:9:1;;6117:128::o

ipfs://482df1807b067dae47581c916164a2049a0863c8e6390761d8bcafcebb68c640