Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-05-27
*/

// File: contracts/bonding-curves/CurveErrorCodes.sol

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity ^0.8.0;

contract CurveErrorCodes {
    enum Error {
        OK, // No error
        INVALID_NUMITEMS, // The numItem value is 0
        SPOT_PRICE_OVERFLOW // The updated spot price doesn't fit into 128 bits
    }
}

// File: contracts/bonding-curves/ICurve.sol
pragma solidity ^0.8.0;

interface ICurve {
    /**
        @notice Validates if a delta value is valid for the curve. The criteria for
        validity can be different for each type of curve, for instance ExponentialCurve
        requires delta to be greater than 1.
        @param delta The delta value to be validated
        @return valid True if delta is valid, false otherwise
     */
    function validateDelta(uint128 delta) external pure returns (bool valid);

    /**
        @notice Validates if a new spot price is valid for the curve. Spot price is generally assumed to be the immediate sell price of 1 NFT to the pool, in units of the pool's paired token.
        @param newSpotPrice The new spot price to be set
        @return valid True if the new spot price is valid, false otherwise
     */
    function validateSpotPrice(uint128 newSpotPrice)
        external
        view
        returns (bool valid);

    /**
        @notice Given the current state of the pair and the trade, computes how much the user
        should pay to purchase an NFT from the pair, the new spot price, and other values.
        @param spotPrice The current selling spot price of the pair, in tokens
        @param delta The delta parameter of the pair, what it means depends on the curve
        @param numItems The number of NFTs the user is buying from the pair
        @param feeMultiplier Determines how much fee the LP takes from this trade, 18 decimals
        @param protocolFeeMultiplier Determines how much fee the protocol takes from this trade, 18 decimals
        @return error Any math calculation errors, only Error.OK means the returned values are valid
        @return newSpotPrice The updated selling spot price, in tokens
        @return newDelta The updated delta, used to parameterize the bonding curve
        @return inputValue The amount that the user should pay, in tokens
        @return protocolFee The amount of fee to send to the protocol, in tokens
     */
    function getBuyInfo(
        uint128 spotPrice,
        uint128 delta,
        uint256 numItems,
        uint256 feeMultiplier,
        uint256 protocolFeeMultiplier
    )
        external
        view
        returns (
            CurveErrorCodes.Error error,
            uint128 newSpotPrice,
            uint128 newDelta,
            uint256 inputValue,
            uint256 protocolFee
        );

    /**
        @notice Given the current state of the pair and the trade, computes how much the user
        should receive when selling NFTs to the pair, the new spot price, and other values.
        @param spotPrice The current selling spot price of the pair, in tokens
        @param delta The delta parameter of the pair, what it means depends on the curve
        @param numItems The number of NFTs the user is selling to the pair
        @param feeMultiplier Determines how much fee the LP takes from this trade, 18 decimals
        @param protocolFeeMultiplier Determines how much fee the protocol takes from this trade, 18 decimals
        @return error Any math calculation errors, only Error.OK means the returned values are valid
        @return newSpotPrice The updated selling spot price, in tokens
        @return newDelta The updated delta, used to parameterize the bonding curve
        @return outputValue The amount that the user should receive, in tokens
        @return protocolFee The amount of fee to send to the protocol, in tokens
     */
    function getSellInfo(
        uint128 spotPrice,
        uint128 delta,
        uint256 numItems,
        uint256 feeMultiplier,
        uint256 protocolFeeMultiplier
    )
        external
        view
        returns (
            CurveErrorCodes.Error error,
            uint128 newSpotPrice,
            uint128 newDelta,
            uint256 outputValue,
            uint256 protocolFee
        );
}

// File: contracts/imports/FixedPointMathLib.sol
pragma solidity >=0.8.0;

/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Modified from Dappsys V2 (https://github.com/dapp-org/dappsys-v2/blob/main/src/math.sol)
/// and ABDK (https://github.com/abdk-consulting/abdk-libraries-solidity/blob/master/ABDKMath64x64.sol)
library FixedPointMathLib {
    /*///////////////////////////////////////////////////////////////
                            COMMON BASE UNITS
    //////////////////////////////////////////////////////////////*/

    uint256 internal constant YAD = 1e8;
    uint256 internal constant WAD = 1e18;
    uint256 internal constant RAY = 1e27;
    uint256 internal constant RAD = 1e45;

    /*///////////////////////////////////////////////////////////////
                         FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function fmul(
        uint256 x,
        uint256 y,
        uint256 baseUnit
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * y in z for now.
            z := mul(x, y)

            // Equivalent to require(x == 0 || (x * y) / x == y)
            if iszero(or(iszero(x), eq(div(z, x), y))) {
                revert(0, 0)
            }

            // If baseUnit is zero this will return zero instead of reverting.
            z := div(z, baseUnit)
        }
    }

    function fdiv(
        uint256 x,
        uint256 y,
        uint256 baseUnit
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * baseUnit in z for now.
            z := mul(x, baseUnit)

            if or(
                // Revert if y is zero to ensure we don't divide by zero below.
                iszero(y),
                // Equivalent to require(x == 0 || (x * baseUnit) / x == baseUnit)
                iszero(or(iszero(x), eq(div(z, x), baseUnit)))
            ) {
                revert(0, 0)
            }

            // We ensure y is not zero above, so there is never division by zero here.
            z := div(z, y)
        }
    }

    function fpow(
        uint256 x,
        uint256 n,
        uint256 baseUnit
    ) internal pure returns (uint256 z) {
        assembly {
            switch x
            case 0 {
                switch n
                case 0 {
                    z := baseUnit
                }
                default {
                    z := 0
                }
            }
            default {
                switch mod(n, 2)
                case 0 {
                    z := baseUnit
                }
                default {
                    z := x
                }
                let half := div(baseUnit, 2)
                for {
                    n := div(n, 2)
                } n {
                    n := div(n, 2)
                } {
                    let xx := mul(x, x)
                    if iszero(eq(div(xx, x), x)) {
                        revert(0, 0)
                    }
                    let xxRound := add(xx, half)
                    if lt(xxRound, xx) {
                        revert(0, 0)
                    }
                    x := div(xxRound, baseUnit)
                    if mod(n, 2) {
                        let zx := mul(z, x)
                        if and(iszero(iszero(x)), iszero(eq(div(zx, x), z))) {
                            revert(0, 0)
                        }
                        let zxRound := add(zx, half)
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }
                        z := div(zxRound, baseUnit)
                    }
                }
            }
        }
    }

    /*///////////////////////////////////////////////////////////////
                        GENERAL NUMBER UTILITIES
    //////////////////////////////////////////////////////////////*/

    function sqrt(uint256 x) internal pure returns (uint256 result) {
        if (x == 0) return 0;

        result = 1;

        uint256 xAux = x;

        if (xAux >= 0x100000000000000000000000000000000) {
            xAux >>= 128;
            result <<= 64;
        }

        if (xAux >= 0x10000000000000000) {
            xAux >>= 64;
            result <<= 32;
        }

        if (xAux >= 0x100000000) {
            xAux >>= 32;
            result <<= 16;
        }

        if (xAux >= 0x10000) {
            xAux >>= 16;
            result <<= 8;
        }

        if (xAux >= 0x100) {
            xAux >>= 8;
            result <<= 4;
        }

        if (xAux >= 0x10) {
            xAux >>= 4;
            result <<= 2;
        }

        if (xAux >= 0x8) result <<= 1;

        unchecked {
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;
            result = (result + x / result) >> 1;

            uint256 roundedDownResult = x / result;

            if (result > roundedDownResult) result = roundedDownResult;
        }
    }

    function min(uint256 x, uint256 y) internal pure returns (uint256 z) {
        return x < y ? x : y;
    }

    function max(uint256 x, uint256 y) internal pure returns (uint256 z) {
        return x > y ? x : y;
    }
}

// File: contracts/bonding-curves/ExponentialCurve.sol

pragma solidity ^0.8.0;

/*
    @author 0xmons and boredGenius
    @notice Bonding curve logic for an exponential curve, where each buy/sell changes spot price by multiplying/dividing delta
*/
contract ExponentialCurve is ICurve, CurveErrorCodes {
    using FixedPointMathLib for uint256;

    // minimum price to prevent numerical issues
    uint256 public constant MIN_PRICE = 1 gwei;

    /**
        @dev See {ICurve-validateDelta}
     */
    function validateDelta(uint128 delta)
        external
        pure
        override
        returns (bool)
    {
        return delta > FixedPointMathLib.WAD;
    }

    /**
        @dev See {ICurve-validateSpotPrice}
     */
    function validateSpotPrice(uint128 newSpotPrice)
        external
        pure
        override
        returns (bool)
    {
        return newSpotPrice >= MIN_PRICE;
    }

    /**
        @dev See {ICurve-getBuyInfo}
     */
    function getBuyInfo(
        uint128 spotPrice,
        uint128 delta,
        uint256 numItems,
        uint256 feeMultiplier,
        uint256 protocolFeeMultiplier
    )
        external
        pure
        override
        returns (
            Error error,
            uint128 newSpotPrice,
            uint128 newDelta,
            uint256 inputValue,
            uint256 protocolFee
        )
    {
        // NOTE: we assume delta is > 1, as checked by validateDelta()
        // We only calculate changes for buying 1 or more NFTs
        if (numItems == 0) {
            return (Error.INVALID_NUMITEMS, 0, 0, 0, 0);
        }

        uint256 deltaPowN = uint256(delta).fpow(
            numItems,
            FixedPointMathLib.WAD
        );

        // For an exponential curve, the spot price is multiplied by delta for each item bought
        uint256 newSpotPrice_ = uint256(spotPrice).fmul(
            deltaPowN,
            FixedPointMathLib.WAD
        );
        if (newSpotPrice_ > type(uint128).max) {
            return (Error.SPOT_PRICE_OVERFLOW, 0, 0, 0, 0);
        }
        newSpotPrice = uint128(newSpotPrice_);

        // Spot price is assumed to be the instant sell price. To avoid arbitraging LPs, we adjust the buy price upwards.
        // If spot price for buy and sell were the same, then someone could buy 1 NFT and then sell for immediate profit.
        // EX: Let S be spot price. Then buying 1 NFT costs S ETH, now new spot price is (S * delta).
        // The same person could then sell for (S * delta) ETH, netting them delta ETH profit.
        // If spot price for buy and sell differ by delta, then buying costs (S * delta) ETH.
        // The new spot price would become (S * delta), so selling would also yield (S * delta) ETH.
        uint256 buySpotPrice = uint256(spotPrice).fmul(
            delta,
            FixedPointMathLib.WAD
        );

        // If the user buys n items, then the total cost is equal to:
        // buySpotPrice + (delta * buySpotPrice) + (delta^2 * buySpotPrice) + ... (delta^(numItems - 1) * buySpotPrice)
        // This is equal to buySpotPrice * (delta^n - 1) / (delta - 1)
        inputValue = buySpotPrice.fmul(
            (deltaPowN - FixedPointMathLib.WAD).fdiv(
                delta - FixedPointMathLib.WAD,
                FixedPointMathLib.WAD
            ),
            FixedPointMathLib.WAD
        );

        // Account for the protocol fee, a flat percentage of the buy amount
        protocolFee = inputValue.fmul(
            protocolFeeMultiplier,
            FixedPointMathLib.WAD
        );

        // Account for the trade fee, only for Trade pools
        inputValue += inputValue.fmul(feeMultiplier, FixedPointMathLib.WAD);

        // Add the protocol fee to the required input amount
        inputValue += protocolFee;

        // Keep delta the same
        newDelta = delta;

        // If we got all the way here, no math error happened
        error = Error.OK;
    }

    /**
        @dev See {ICurve-getSellInfo}
        If newSpotPrice is less than MIN_PRICE, newSpotPrice is set to MIN_PRICE instead.
        This is to prevent the spot price from ever becoming 0, which would decouple the price
        from the bonding curve (since 0 * delta is still 0)
     */
    function getSellInfo(
        uint128 spotPrice,
        uint128 delta,
        uint256 numItems,
        uint256 feeMultiplier,
        uint256 protocolFeeMultiplier
    )
        external
        pure
        override
        returns (
            Error error,
            uint128 newSpotPrice,
            uint128 newDelta,
            uint256 outputValue,
            uint256 protocolFee
        )
    {
        // NOTE: we assume delta is > 1, as checked by validateDelta()

        // We only calculate changes for buying 1 or more NFTs
        if (numItems == 0) {
            return (Error.INVALID_NUMITEMS, 0, 0, 0, 0);
        }

        uint256 invDelta = FixedPointMathLib.WAD.fdiv(
            delta,
            FixedPointMathLib.WAD
        );
        uint256 invDeltaPowN = invDelta.fpow(numItems, FixedPointMathLib.WAD);

        // For an exponential curve, the spot price is divided by delta for each item sold
        // safe to convert newSpotPrice directly into uint128 since we know newSpotPrice <= spotPrice
        // and spotPrice <= type(uint128).max
        newSpotPrice = uint128(
            uint256(spotPrice).fmul(invDeltaPowN, FixedPointMathLib.WAD)
        );
        if (newSpotPrice < MIN_PRICE) {
            newSpotPrice = uint128(MIN_PRICE);
        }

        // If the user sells n items, then the total revenue is equal to:
        // spotPrice + ((1 / delta) * spotPrice) + ((1 / delta)^2 * spotPrice) + ... ((1 / delta)^(numItems - 1) * spotPrice)
        // This is equal to spotPrice * (1 - (1 / delta^n)) / (1 - (1 / delta))
        outputValue = uint256(spotPrice).fmul(
            (FixedPointMathLib.WAD - invDeltaPowN).fdiv(
                FixedPointMathLib.WAD - invDelta,
                FixedPointMathLib.WAD
            ),
            FixedPointMathLib.WAD
        );

        // Account for the protocol fee, a flat percentage of the sell amount
        protocolFee = outputValue.fmul(
            protocolFeeMultiplier,
            FixedPointMathLib.WAD
        );

        // Account for the trade fee, only for Trade pools
        outputValue -= outputValue.fmul(feeMultiplier, FixedPointMathLib.WAD);

        // Remove the protocol fee from the output amount
        outputValue -= protocolFee;

        // Keep delta the same
        newDelta = delta;

        // If we got all the way here, no math error happened
        error = Error.OK;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"MIN_PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint128","name":"spotPrice","type":"uint128"},{"internalType":"uint128","name":"delta","type":"uint128"},{"internalType":"uint256","name":"numItems","type":"uint256"},{"internalType":"uint256","name":"feeMultiplier","type":"uint256"},{"internalType":"uint256","name":"protocolFeeMultiplier","type":"uint256"}],"name":"getBuyInfo","outputs":[{"internalType":"enum CurveErrorCodes.Error","name":"error","type":"uint8"},{"internalType":"uint128","name":"newSpotPrice","type":"uint128"},{"internalType":"uint128","name":"newDelta","type":"uint128"},{"internalType":"uint256","name":"inputValue","type":"uint256"},{"internalType":"uint256","name":"protocolFee","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint128","name":"spotPrice","type":"uint128"},{"internalType":"uint128","name":"delta","type":"uint128"},{"internalType":"uint256","name":"numItems","type":"uint256"},{"internalType":"uint256","name":"feeMultiplier","type":"uint256"},{"internalType":"uint256","name":"protocolFeeMultiplier","type":"uint256"}],"name":"getSellInfo","outputs":[{"internalType":"enum CurveErrorCodes.Error","name":"error","type":"uint8"},{"internalType":"uint128","name":"newSpotPrice","type":"uint128"},{"internalType":"uint128","name":"newDelta","type":"uint128"},{"internalType":"uint256","name":"outputValue","type":"uint256"},{"internalType":"uint256","name":"protocolFee","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint128","name":"delta","type":"uint128"}],"name":"validateDelta","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint128","name":"newSpotPrice","type":"uint128"}],"name":"validateSpotPrice","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"}]

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

10220:6604:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14343:2478;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;:::-;;;;;;;;10484:172;;;;;;:::i;:::-;4992:4;-1:-1:-1;;;;;10619:29:0;;;;;10484:172;;;;1731:14:1;;1724:22;1706:41;;1694:2;1679:18;10484:172:0;1566:187:1;10970:3060:0;;;;;;:::i;:::-;;:::i;10727:179::-;;;;;;:::i;:::-;10410:6;-1:-1:-1;;;;;10873:25:0;;;;;;10727:179;10374:42;;10410:6;10374:42;;;;;1904:25:1;;;1892:2;1877:18;10374:42:0;1758:177:1;14343:2478:0;14604:11;14630:20;14665:16;14696:19;14730;14919:8;14931:1;14919:13;14915:89;;-1:-1:-1;14957:22:0;;-1:-1:-1;14981:1:0;;-1:-1:-1;14981:1:0;;-1:-1:-1;14981:1:0;;-1:-1:-1;14981:1:0;14949:43;;14915:89;15016:16;15035:93;4992:4;-1:-1:-1;;;;;15035:93:0;;4992:4;15035:26;:93::i;:::-;15016:112;-1:-1:-1;15139:20:0;15162:46;15016:112;15176:8;4992:4;15162:13;:46::i;:::-;15139:69;-1:-1:-1;15500:60:0;-1:-1:-1;;;;;15500:18:0;;15139:69;4992:4;15500:23;:60::i;:::-;15463:108;;10410:6;15586:12;-1:-1:-1;;;;;15586:24:0;;15582:90;;;10410:6;15627:33;;15582:90;15981:234;16019:149;16081:32;16105:8;4992:4;16081:32;:::i;:::-;4992:4;16020:36;16044:12;4992:4;16020:36;:::i;:::-;16019:43;:149;:43;:149::i;:::-;-1:-1:-1;;;;;15981:18:0;;;4992:4;15981:23;:234::i;:::-;15967:248;-1:-1:-1;16321:99:0;15967:248;16352:21;4992:4;16321:16;:99::i;:::-;16307:113;-1:-1:-1;16508:54:0;:11;16525:13;4992:4;16508:16;:54::i;:::-;16493:69;;;;:::i;:::-;;-1:-1:-1;16634:26:0;16649:11;16493:69;16634:26;:::i;:::-;;;16716:5;16705:16;;16805:8;16797:16;;14766:2055;;14343:2478;;;;;;;;;;;;:::o;10970:3060::-;11230:11;11256:20;11291:16;11322:18;11355:19;11542:8;11554:1;11542:13;11538:89;;-1:-1:-1;11580:22:0;;-1:-1:-1;11604:1:0;;-1:-1:-1;11604:1:0;;-1:-1:-1;11604:1:0;;-1:-1:-1;11604:1:0;11572:43;;11538:89;11639:17;11659:89;-1:-1:-1;;;;;11659:14:0;;11693:8;4992:4;11659:19;:89::i;:::-;11639:109;-1:-1:-1;11858:21:0;11882:94;-1:-1:-1;;;;;11882:18:0;;11639:109;4992:4;11882:23;:94::i;:::-;11858:118;-1:-1:-1;;;;;;11991:33:0;;11987:112;;;12049:25;12076:1;12079;12082;12085;12041:46;;;;;;;;;;;;;;11987:112;12132:13;-1:-1:-1;12132:13:0;12801:20;12824:90;-1:-1:-1;;;;;12824:18:0;;;;:90;;4992:4;12824:23;:90::i;:::-;12801:113;;13204:222;13236:143;4992:4;13295:5;-1:-1:-1;;;;;13295:29:0;;;;;:::i;:::-;4992:4;13237:33;4992:4;13237:9;:33;:::i;13236:143::-;13204:12;;4992:4;13204:17;:222::i;:::-;13191:235;-1:-1:-1;13531:98:0;13191:235;13561:21;4992:4;13531:15;:98::i;:::-;13517:112;-1:-1:-1;13716:53:0;:10;13732:13;4992:4;13716:15;:53::i;:::-;13702:67;;;;:::i;:::-;;-1:-1:-1;13844:25:0;13858:11;13702:67;13844:25;:::i;:::-;14014:8;;10970:3060;;-1:-1:-1;13844:25:0;-1:-1:-1;10970:3060:0;;-1:-1:-1;10970:3060:0;;-1:-1:-1;;;;;;;10970:3060:0:o;5810:704::-;6021:16;;;6158:9;;6280;;6294;;;6291:23;;6277:38;6270:46;6056:275;6053:325;;;6361:1;6358;6351:12;6053:325;6487:9;;;;;5810:704;-1:-1:-1;;5810:704:0:o;6522:1661::-;6633:9;6686:1;6701:203;;;;6952:9;;;6979:62;;;;7095:1;7090:6;;6945:170;;6979:62;7014:8;7009:13;;6945:170;;7159:1;7149:8;7145:16;7218:1;7215;7211:9;7206:14;;7179:971;7240:1;7179:971;;;7339:1;7336;7332:9;7388:1;7384;7380:2;7376:10;7373:17;7363:91;;7429:1;7426;7419:12;7363:91;7499:4;7495:2;7491:13;7541:2;7532:7;7529:15;7526:81;;;7582:1;7579;7572:12;7526:81;7634:22;;;;-1:-1:-1;;7681:9:0;;;7678:453;;;7735:1;7732;7728:9;7811:1;7807;7803:2;7799:10;7796:17;7789:25;7784:1;7777:9;7770:17;7766:49;7763:123;;;7857:1;7854;7847:12;7763:123;7935:4;7931:2;7927:13;7981:2;7972:7;7969:15;7966:89;;;8026:1;8023;8016:12;7966:89;8086:22;;;;-1:-1:-1;;7678:453:0;7277:1;7274;7270:9;7265:14;;7179:971;;;7183:56;6679:1486;;6701:203;6734:1;6753:62;;;;6869:1;6864:6;;6727:162;;6753:62;6788:8;6783:13;;6727:162;;6679:1486;;6522:1661;;;;;:::o;5283:519::-;5487:9;;;5591;;5605;;;5602:16;;5588:31;5578:89;;5650:1;5647;5640:12;5578:89;5768:16;;5283:519;-1:-1:-1;;5283:519:0:o;14:188:1:-;82:20;;-1:-1:-1;;;;;131:46:1;;121:57;;111:85;;192:1;189;182:12;111:85;14:188;;;:::o;207:466::-;302:6;310;318;326;334;387:3;375:9;366:7;362:23;358:33;355:53;;;404:1;401;394:12;355:53;427:29;446:9;427:29;:::i;:::-;417:39;;475:38;509:2;498:9;494:18;475:38;:::i;:::-;207:466;;465:48;;-1:-1:-1;;;;560:2:1;545:18;;532:32;;611:2;596:18;;583:32;;662:3;647:19;;;634:33;;-1:-1:-1;207:466:1:o;678:692::-;929:3;914:19;;963:1;952:13;;942:144;;1008:10;1003:3;999:20;996:1;989:31;1043:4;1040:1;1033:15;1071:4;1068:1;1061:15;942:144;1095:25;;;-1:-1:-1;;;;;1209:15:1;;;1204:2;1189:18;;1182:43;1261:15;;;;1256:2;1241:18;;1234:43;1308:2;1293:18;;1286:34;1351:3;1336:19;1329:35;678:692;:::o;1375:186::-;1434:6;1487:2;1475:9;1466:7;1462:23;1458:32;1455:52;;;1503:1;1500;1493:12;1455:52;1526:29;1545:9;1526:29;:::i;:::-;1516:39;1375:186;-1:-1:-1;;;1375:186:1:o;1940:127::-;2001:10;1996:3;1992:20;1989:1;1982:31;2032:4;2029:1;2022:15;2056:4;2053:1;2046:15;2072:125;2112:4;2140:1;2137;2134:8;2131:34;;;2145:18;;:::i;:::-;-1:-1:-1;2182:9:1;;2072:125::o;2202:128::-;2242:3;2273:1;2269:6;2266:1;2263:13;2260:39;;;2279:18;;:::i;:::-;-1:-1:-1;2315:9:1;;2202:128::o

ipfs://05ef5a53f44a6d843cb7cc3f686ac60df0a2100259d1e8bf49ac3700c21005f5