Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: ISC
pragma solidity ^0.8.21;

import { AggregatorV3Interface } from "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import { ICurvePool } from "../interfaces/Curve/ICurvePool.sol";
import { IYearnVault } from "../interfaces/Yearn/IYearnVault.sol";

/// @title CrvUSDYv3CRVCrvUSDOracle
/// @author Jason (Sturdy) https://github.com/iris112
/// @notice  An oracle for CrvUSD/Yv3CRVCrvUSD
interface ILLAMMA {
    function price_oracle() external view returns (uint256);
}

contract CrvUSDYv3CRVCrvUSDOracle {
    address private constant ETH_CRVUSD_AMM_CONTROLLER = 0x1681195C176239ac5E72d9aeBaCf5b2492E0C4ee;
    address private constant ETH_USD_CHAINLINK = 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419;
    address private constant CRVUSD_USD_CHAINLINK = 0xEEf0C605546958c1f899b6fB336C20671f9cD49F;
    uint8 public constant DECIMALS = 18;

    address public immutable THREECRV_ETH_CHAINLINK;
    address public immutable CURVE_CRVUSD_3CRV_POOL;
    address public immutable YEARN_CRVUSD_3CRV_VAULT;
    uint256 public immutable MAX_ORACLE_DELAY;
    uint256 public immutable PRICE_MIN;

    string public name;

    error CHAINLINK_BAD_PRICE();

    constructor(
        uint256 _maxOracleDelay,
        uint256 _priceMin,
        address _ethUnitchainlinkAddress,
        address _curvePoolAddress,
        address _yearnVaultAddress,
        string memory _name
    ) {
        THREECRV_ETH_CHAINLINK = _ethUnitchainlinkAddress;
        CURVE_CRVUSD_3CRV_POOL = _curvePoolAddress;
        YEARN_CRVUSD_3CRV_VAULT = _yearnVaultAddress;
        name = _name;
        MAX_ORACLE_DELAY = _maxOracleDelay;
        PRICE_MIN = _priceMin;
    }

    /// @notice The ```getPrices``` function is intended to return price of ERC4626 token based on the base asset
    /// @return _isBadData is always false, just sync to other oracle interfaces
    /// @return _priceLow is the lower of the prices
    /// @return _priceHigh is the higher of the prices
    function getPrices() external view returns (bool _isBadData, uint256 _priceLow, uint256 _priceHigh) {
        uint256 crvUSDPriceInETH = _getCrvUSDPrice();
        uint256 yvLPTokenPriceInETH = _getYv3CRVCrvUSDPrice(crvUSDPriceInETH);

        uint256 rate = crvUSDPriceInETH * 1e18 / yvLPTokenPriceInETH;    // crvUSD/yv3CRVCrvUSD

        _priceHigh = rate > PRICE_MIN ? rate : PRICE_MIN;
        _priceLow = _priceHigh;
    }

    /**
     * @dev Get price for crvUSD
     */
    function _getCrvUSDPrice() internal view returns (uint256) {
        // Get crvUSD price from AMM controller
        uint256 crvUSDPrice;
        uint256 rate = ILLAMMA(ETH_CRVUSD_AMM_CONTROLLER).price_oracle();  // ETH/crvUSD
        rate = 1e36 / rate; // crvUSD/ETH

        // Get crvUSD price from chainlink
        (, int256 _answer, , uint256 _updatedAt, ) = AggregatorV3Interface(CRVUSD_USD_CHAINLINK)
            .latestRoundData();     // crvUSD/USD
        // If data is stale or negative, set bad data to true and return
        if (_answer <= 0 || (block.timestamp - _updatedAt > MAX_ORACLE_DELAY)) {
            revert CHAINLINK_BAD_PRICE();
        }
        crvUSDPrice = uint256(_answer);

        // Get ETH price from chainlink
        (, _answer, , _updatedAt, ) = AggregatorV3Interface(ETH_USD_CHAINLINK)
            .latestRoundData();     // ETH/USD
        // If data is stale or negative, set bad data to true and return
        if (_answer <= 0 || (block.timestamp - _updatedAt > MAX_ORACLE_DELAY)) {
            revert CHAINLINK_BAD_PRICE();
        }
        crvUSDPrice = crvUSDPrice * 1e18 / uint256(_answer);    // crvUSD/ETH

        return Math.min(rate, crvUSDPrice);
    }

    /**
     * @dev Get price for yearn Curve-(USDT/USDC/DAI/FRAX)-CrvUSD LP Token
     */
    function _getYv3CRVCrvUSDPrice(uint256 _crvUSDPrice) internal view returns (uint256) {
        // Get (USDT/USDC/DAI/FRAX) price from chainlink
        (, int256 _answer, , uint256 _updatedAt, ) = AggregatorV3Interface(THREECRV_ETH_CHAINLINK)
            .latestRoundData();     // 3CRV/ETH
        // If data is stale or negative, set bad data to true and return
        if (_answer <= 0 || (block.timestamp - _updatedAt > MAX_ORACLE_DELAY)) {
            revert CHAINLINK_BAD_PRICE();
        }

        uint256 minStable = Math.min(uint256(_answer), _crvUSDPrice);
        uint256 curveLPTokenPrice = (ICurvePool(CURVE_CRVUSD_3CRV_POOL).get_virtual_price() * minStable) / 1e18;

        return curveLPTokenPrice * IYearnVault(YEARN_CRVUSD_3CRV_VAULT).pricePerShare() / 1e18;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

/**
 * @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);
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface AggregatorV3Interface {
  function decimals() external view returns (uint8);

  function description() external view returns (string memory);

  function version() external view returns (uint256);

  function getRoundData(
    uint80 _roundId
  ) external view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);

  function latestRoundData()
    external
    view
    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound);
}

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

interface ICurvePool {
    function get_virtual_price() external view returns (uint256 price);

    function price_oracle() external view returns (uint256);

    function price_oracle(uint256 i) external view returns (uint256);

    function balances(uint256 _id) external view returns (uint256);

    function calc_token_amount(
        uint256[2] memory _amounts,
        bool _is_deposit
    ) external view returns (uint256);

    function calc_token_amount(
        uint256[] memory _amounts,
        bool _is_deposit
    ) external view returns (uint256);

    function calc_withdraw_one_coin(uint256 _burn_amount, int128 i) external view returns (uint256);

    function add_liquidity(uint256[2] memory amounts, uint256 _min_mint_amount) external;

    function add_liquidity(uint256[] memory amounts, uint256 _min_mint_amount) external;
}

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

interface IYearnVault {
    function pricePerShare() external view returns (uint256 price);

    function deposit(uint256 _amount, address recipient) external returns (uint256);

    function withdraw(
        uint256 maxShares,
        address recipient,
        uint256 maxLoss
    ) external returns (uint256);
}

{
  "viaIR": true,
  "optimizer": {
    "enabled": true,
    "runs": 1660
  },
  "evmVersion": "paris",
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "metadata": {
    "useLiteralContent": true
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"_maxOracleDelay","type":"uint256"},{"internalType":"uint256","name":"_priceMin","type":"uint256"},{"internalType":"address","name":"_ethUnitchainlinkAddress","type":"address"},{"internalType":"address","name":"_curvePoolAddress","type":"address"},{"internalType":"address","name":"_yearnVaultAddress","type":"address"},{"internalType":"string","name":"_name","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"CHAINLINK_BAD_PRICE","type":"error"},{"inputs":[],"name":"CURVE_CRVUSD_3CRV_POOL","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DECIMALS","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_ORACLE_DELAY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRICE_MIN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"THREECRV_ETH_CHAINLINK","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"YEARN_CRVUSD_3CRV_VAULT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getPrices","outputs":[{"internalType":"bool","name":"_isBadData","type":"bool"},{"internalType":"uint256","name":"_priceLow","type":"uint256"},{"internalType":"uint256","name":"_priceHigh","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000151800000000000000000000000000000000000000000000000000c1208f15c24a120000000000000000000000000986b5e1e1755e3c2440e960477f25201b0a8bbd40000000000000000000000004dece678ceceb27446b35c672dc7d61f30bad69e0000000000000000000000007ca00559b978cfde81297849be6151d3ccb408a900000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000001c437276555344597655534443437276555344506169724f7261636c6500000000

-----Decoded View---------------
Arg [0] : _maxOracleDelay (uint256): 86400
Arg [1] : _priceMin (uint256): 869767510761972000
Arg [2] : _ethUnitchainlinkAddress (address): 0x986b5E1e1755e3C2440e960477f25201B0a8bbD4
Arg [3] : _curvePoolAddress (address): 0x4DEcE678ceceb27446b35C672dC7d61F30bAD69E
Arg [4] : _yearnVaultAddress (address): 0x7cA00559B978CFde81297849be6151d3ccB408A9
Arg [5] : _name (string): CrvUSDYvUSDCCrvUSDPairOracle

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000015180
Arg [1] : 0000000000000000000000000000000000000000000000000c1208f15c24a120
Arg [2] : 000000000000000000000000986b5e1e1755e3c2440e960477f25201b0a8bbd4
Arg [3] : 0000000000000000000000004dece678ceceb27446b35c672dc7d61f30bad69e
Arg [4] : 0000000000000000000000007ca00559b978cfde81297849be6151d3ccb408a9
Arg [5] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [6] : 000000000000000000000000000000000000000000000000000000000000001c
Arg [7] : 437276555344597655534443437276555344506169724f7261636c6500000000

586:4049:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1118:41;586:4049;;;;;;;;;;;;;;;;;;;;;;;2707:49;679:42;2707:49;;;;;;;;679:42;2707:49;;;;;;;;;;;586:4049;;;;;;2788:4;586:4049;;;679:42;2912:74;;;;;;;;;868:42;2912:74;;;;;;679:42;586:4049;;2912:74;;;586:4049;3091:12;;;;;;;:65;;;586:4049;3087:124;;;586:4049;;3331:71;;;;;;;772:42;3331:71;;;;;;679:42;586:4049;;3331:71;;;586:4049;3504:12;;;;;;;:65;;;586:4049;3500:124;;;3661:4;586:4049;;;;;;;;;;;;;;;;3647:37;;;;:::i;:::-;672:5:1;;;;;;:13;;;586:4049:4;;;;4047:76;;;4069:22;;;;;;586:4049;4047:76;;;;;;;679:42;586:4049;;4047:76;;;672:13:1;4226:12:4;;;;;;;;:65;;;672:13:1;4222:124:4;;;672:5:1;;;;;;:13;586:4049:4;;679:42;4455:54;;4466:22;;;;;;586:4049;4455:54;;;;;;;;;;;;;;;;;672:13:1;4455:66:4;;;;;:::i;:::-;586:4049;;;;4567:52;;;;679:42;4567:52;;4579:23;586:4049;4567:52;;;;;;;;;;;;;;672:13:1;4547:72:4;;;;;:::i;:::-;586:4049;;;;;;;;;;;;;;;;;2322:45;;;;;;:::i;:::-;2424:9;2417:16;;;;;;:35;;;;586:4049;;;;;;;;;;;;2417:35;;;;;;;586:4049;;;;;-1:-1:-1;;;586:4049:4;;;;4567:52;;;;;;;;;;;;;;;;;;:::i;:::-;;;679:42;;;;;;;4547:72;4567:52;;679:42;586:4049;;;4567:52;;;;;;586:4049;;679:42;586:4049;;679:42;;;;4455:54;;;;;;;;;;;;;;;;;;;:::i;:::-;;;679:42;;;;;4455:66;679:42;;;;;4455:54;;;;679:42;586:4049;;;4455:54;;;;;;586:4049;;679:42;586:4049;;679:42;;;;672:13:1;;;;;4222:124:4;586:4049;;;-1:-1:-1;;;4314:21:4;;;4226:65;4243:28;:15;;;:28;:::i;:::-;4274:16;-1:-1:-1;4226:65:4;;;4047:76;;;;;;;;;;-1:-1:-1;4047:76:4;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;;;;;;;;;;;672:13:1;;;;;;586:4049:4;;;;;-1:-1:-1;;;586:4049:4;;;;3500:124;586:4049;;;-1:-1:-1;;;3592:21:4;;;3504:65;3521:28;:15;;;:28;:::i;:::-;3552:16;-1:-1:-1;3504:65:4;;;3331:71;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;3091:65;3108:28;:15;;;:28;:::i;:::-;3139:16;-1:-1:-1;3091:65:4;;;2912:74;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;586:4049;;;;;-1:-1:-1;;;586:4049:4;;;;2707:49;;;;;;;;;;;;;;;;:::i;:::-;;;679:42;;;;;2707:49;;;679:42;586:4049;;;2707:49;;;;;;586:4049;;679:42;586:4049;;679:42;;;;586:4049;;;;;;;;;;;;;;;;;;1011:47;586:4049;;;;;;;;;;;;;;;;;;;;;;1064:48;586:4049;;;;;;;;;;;;;;;;;;;;;1165:34;586:4049;;;;;;;;;;;;;;;;;;;;949:2;586:4049;;;;;;;;;;;;;;;;;;;;;958:47;586:4049;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;586:4049:4;;;;;;;;-1:-1:-1;;586:4049:4;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;586:4049:4;;;;;;;;;;;-1:-1:-1;586:4049:4;;;;;;;;;-1:-1:-1;586:4049:4;;-1:-1:-1;;586:4049:4;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;586:4049:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;586:4049:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;-1:-1:-1;;;586:4049:4;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;-1:-1:-1;;;586:4049:4;;;;;;;;;;;;;;;:::o;:::-;-1:-1:-1;;;586:4049:4;;;;;;;;868:42;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;679;868;;;;;;679;868;;;:::i;:::-;;:::o;:::-;;;;;;;;;;:::o

ipfs://6a1a2d4d51258d8b2799e3fe53967a4cbb137f5349029db3fb0e85e8b07b907c