Overview
ETH Balance
0 ETH
Eth Value
$0.00More Info
Private Name Tags
ContractCreator
View more zero value Internal Transactions in Advanced View mode
Advanced mode:
Loading...
Loading
Contract Name:
Comptroller
Compiler Version
v0.5.16+commit.9c3226ce
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2020-09-12 */ // File: contracts/ComptrollerInterface.sol pragma solidity ^0.5.16; contract ComptrollerInterface { /// @notice Indicator that this is a Comptroller contract (for inspection) bool public constant isComptroller = true; /*** Assets You Are In ***/ function enterMarkets(address[] calldata cTokens) external returns (uint[] memory); function exitMarket(address cToken) external returns (uint); /*** Policy Hooks ***/ function mintAllowed(address cToken, address minter, uint mintAmount) external returns (uint); function mintVerify(address cToken, address minter, uint mintAmount, uint mintTokens) external; function redeemAllowed(address cToken, address redeemer, uint redeemTokens) external returns (uint); function redeemVerify(address cToken, address redeemer, uint redeemAmount, uint redeemTokens) external; function borrowAllowed(address cToken, address borrower, uint borrowAmount) external returns (uint); function borrowVerify(address cToken, address borrower, uint borrowAmount) external; function repayBorrowAllowed( address cToken, address payer, address borrower, uint repayAmount) external returns (uint); function repayBorrowVerify( address cToken, address payer, address borrower, uint repayAmount, uint borrowerIndex) external; function liquidateBorrowAllowed( address cTokenBorrowed, address cTokenCollateral, address liquidator, address borrower, uint repayAmount) external returns (uint); function liquidateBorrowVerify( address cTokenBorrowed, address cTokenCollateral, address liquidator, address borrower, uint repayAmount, uint seizeTokens) external; function seizeAllowed( address cTokenCollateral, address cTokenBorrowed, address liquidator, address borrower, uint seizeTokens) external returns (uint); function seizeVerify( address cTokenCollateral, address cTokenBorrowed, address liquidator, address borrower, uint seizeTokens) external; function transferAllowed(address cToken, address src, address dst, uint transferTokens) external returns (uint); function transferVerify(address cToken, address src, address dst, uint transferTokens) external; /*** Liquidity/Liquidation Calculations ***/ function liquidateCalculateSeizeTokens( address cTokenBorrowed, address cTokenCollateral, uint repayAmount) external view returns (uint, uint); } // File: contracts/InterestRateModel.sol pragma solidity ^0.5.16; /** * @title Compound's InterestRateModel Interface * @author Compound */ contract InterestRateModel { /// @notice Indicator that this is an InterestRateModel contract (for inspection) bool public constant isInterestRateModel = true; /** * @notice Calculates the current borrow interest rate per block * @param cash The total amount of cash the market has * @param borrows The total amount of borrows the market has outstanding * @param reserves The total amnount of reserves the market has * @return The borrow rate per block (as a percentage, and scaled by 1e18) */ function getBorrowRate(uint cash, uint borrows, uint reserves) external view returns (uint); /** * @notice Calculates the current supply interest rate per block * @param cash The total amount of cash the market has * @param borrows The total amount of borrows the market has outstanding * @param reserves The total amnount of reserves the market has * @param reserveFactorMantissa The current reserve factor the market has * @return The supply rate per block (as a percentage, and scaled by 1e18) */ function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) external view returns (uint); } // File: contracts/CTokenInterfaces.sol pragma solidity ^0.5.16; contract CTokenStorage { /** * @dev Guard variable for re-entrancy checks */ bool internal _notEntered; /** * @notice EIP-20 token name for this token */ string public name; /** * @notice EIP-20 token symbol for this token */ string public symbol; /** * @notice EIP-20 token decimals for this token */ uint8 public decimals; /** * @notice Maximum borrow rate that can ever be applied (.0005% / block) */ uint internal constant borrowRateMaxMantissa = 0.0005e16; /** * @notice Maximum fraction of interest that can be set aside for reserves */ uint internal constant reserveFactorMaxMantissa = 1e18; /** * @notice Administrator for this contract */ address payable public admin; /** * @notice Pending administrator for this contract */ address payable public pendingAdmin; /** * @notice Contract which oversees inter-cToken operations */ ComptrollerInterface public comptroller; /** * @notice Model which tells what the current interest rate should be */ InterestRateModel public interestRateModel; /** * @notice Initial exchange rate used when minting the first CTokens (used when totalSupply = 0) */ uint internal initialExchangeRateMantissa; /** * @notice Fraction of interest currently set aside for reserves */ uint public reserveFactorMantissa; /** * @notice Block number that interest was last accrued at */ uint public accrualBlockNumber; /** * @notice Accumulator of the total earned interest rate since the opening of the market */ uint public borrowIndex; /** * @notice Total amount of outstanding borrows of the underlying in this market */ uint public totalBorrows; /** * @notice Total amount of reserves of the underlying held in this market */ uint public totalReserves; /** * @notice Total number of tokens in circulation */ uint public totalSupply; /** * @notice Official record of token balances for each account */ mapping (address => uint) internal accountTokens; /** * @notice Approved token transfer amounts on behalf of others */ mapping (address => mapping (address => uint)) internal transferAllowances; /** * @notice Container for borrow balance information * @member principal Total balance (with accrued interest), after applying the most recent balance-changing action * @member interestIndex Global borrowIndex as of the most recent balance-changing action */ struct BorrowSnapshot { uint principal; uint interestIndex; } /** * @notice Mapping of account addresses to outstanding borrow balances */ mapping(address => BorrowSnapshot) internal accountBorrows; } contract CTokenInterface is CTokenStorage { /** * @notice Indicator that this is a CToken contract (for inspection) */ bool public constant isCToken = true; /*** Market Events ***/ /** * @notice Event emitted when interest is accrued */ event AccrueInterest(uint cashPrior, uint interestAccumulated, uint borrowIndex, uint totalBorrows); /** * @notice Event emitted when tokens are minted */ event Mint(address minter, uint mintAmount, uint mintTokens); /** * @notice Event emitted when tokens are redeemed */ event Redeem(address redeemer, uint redeemAmount, uint redeemTokens); /** * @notice Event emitted when underlying is borrowed */ event Borrow(address borrower, uint borrowAmount, uint accountBorrows, uint totalBorrows); /** * @notice Event emitted when a borrow is repaid */ event RepayBorrow(address payer, address borrower, uint repayAmount, uint accountBorrows, uint totalBorrows); /** * @notice Event emitted when a borrow is liquidated */ event LiquidateBorrow(address liquidator, address borrower, uint repayAmount, address cTokenCollateral, uint seizeTokens); /*** Admin Events ***/ /** * @notice Event emitted when pendingAdmin is changed */ event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin); /** * @notice Event emitted when pendingAdmin is accepted, which means admin is updated */ event NewAdmin(address oldAdmin, address newAdmin); /** * @notice Event emitted when comptroller is changed */ event NewComptroller(ComptrollerInterface oldComptroller, ComptrollerInterface newComptroller); /** * @notice Event emitted when interestRateModel is changed */ event NewMarketInterestRateModel(InterestRateModel oldInterestRateModel, InterestRateModel newInterestRateModel); /** * @notice Event emitted when the reserve factor is changed */ event NewReserveFactor(uint oldReserveFactorMantissa, uint newReserveFactorMantissa); /** * @notice Event emitted when the reserves are added */ event ReservesAdded(address benefactor, uint addAmount, uint newTotalReserves); /** * @notice Event emitted when the reserves are reduced */ event ReservesReduced(address admin, uint reduceAmount, uint newTotalReserves); /** * @notice EIP20 Transfer event */ event Transfer(address indexed from, address indexed to, uint amount); /** * @notice EIP20 Approval event */ event Approval(address indexed owner, address indexed spender, uint amount); /** * @notice Failure event */ event Failure(uint error, uint info, uint detail); /*** User Interface ***/ function transfer(address dst, uint amount) external returns (bool); function transferFrom(address src, address dst, uint amount) external returns (bool); function approve(address spender, uint amount) external returns (bool); function allowance(address owner, address spender) external view returns (uint); function balanceOf(address owner) external view returns (uint); function balanceOfUnderlying(address owner) external returns (uint); function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint); function borrowRatePerBlock() external view returns (uint); function supplyRatePerBlock() external view returns (uint); function totalBorrowsCurrent() external returns (uint); function borrowBalanceCurrent(address account) external returns (uint); function borrowBalanceStored(address account) public view returns (uint); function exchangeRateCurrent() public returns (uint); function exchangeRateStored() public view returns (uint); function getCash() external view returns (uint); function accrueInterest() public returns (uint); function seize(address liquidator, address borrower, uint seizeTokens) external returns (uint); /*** Admin Functions ***/ function _setPendingAdmin(address payable newPendingAdmin) external returns (uint); function _acceptAdmin() external returns (uint); function _setComptroller(ComptrollerInterface newComptroller) public returns (uint); function _setReserveFactor(uint newReserveFactorMantissa) external returns (uint); function _reduceReserves(uint reduceAmount) external returns (uint); function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint); } contract CErc20Storage { /** * @notice Underlying asset for this CToken */ address public underlying; } contract CErc20Interface is CErc20Storage { /*** User Interface ***/ function mint(uint mintAmount) external returns (uint); function redeem(uint redeemTokens) external returns (uint); function redeemUnderlying(uint redeemAmount) external returns (uint); function borrow(uint borrowAmount) external returns (uint); function repayBorrow(uint repayAmount) external returns (uint); function repayBorrowBehalf(address borrower, uint repayAmount) external returns (uint); function liquidateBorrow(address borrower, uint repayAmount, CTokenInterface cTokenCollateral) external returns (uint); /*** Admin Functions ***/ function _addReserves(uint addAmount) external returns (uint); } contract CDelegationStorage { /** * @notice Implementation address for this contract */ address public implementation; } contract CDelegatorInterface is CDelegationStorage { /** * @notice Emitted when implementation is changed */ event NewImplementation(address oldImplementation, address newImplementation); /** * @notice Called by the admin to update the implementation of the delegator * @param implementation_ The address of the new implementation for delegation * @param allowResign Flag to indicate whether to call _resignImplementation on the old implementation * @param becomeImplementationData The encoded bytes data to be passed to _becomeImplementation */ function _setImplementation(address implementation_, bool allowResign, bytes memory becomeImplementationData) public; } contract CDelegateInterface is CDelegationStorage { /** * @notice Called by the delegator on a delegate to initialize it for duty * @dev Should revert if any issues arise which make it unfit for delegation * @param data The encoded bytes data for any initialization */ function _becomeImplementation(bytes memory data) public; /** * @notice Called by the delegator on a delegate to forfeit its responsibility */ function _resignImplementation() public; } // File: contracts/ErrorReporter.sol pragma solidity ^0.5.16; contract ComptrollerErrorReporter { enum Error { NO_ERROR, UNAUTHORIZED, COMPTROLLER_MISMATCH, INSUFFICIENT_SHORTFALL, INSUFFICIENT_LIQUIDITY, INVALID_CLOSE_FACTOR, INVALID_COLLATERAL_FACTOR, INVALID_LIQUIDATION_INCENTIVE, MARKET_NOT_ENTERED, // no longer possible MARKET_NOT_LISTED, MARKET_ALREADY_LISTED, MATH_ERROR, NONZERO_BORROW_BALANCE, PRICE_ERROR, REJECTION, SNAPSHOT_ERROR, TOO_MANY_ASSETS, TOO_MUCH_REPAY } enum FailureInfo { ACCEPT_ADMIN_PENDING_ADMIN_CHECK, ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK, EXIT_MARKET_BALANCE_OWED, EXIT_MARKET_REJECTION, SET_CLOSE_FACTOR_OWNER_CHECK, SET_CLOSE_FACTOR_VALIDATION, SET_COLLATERAL_FACTOR_OWNER_CHECK, SET_COLLATERAL_FACTOR_NO_EXISTS, SET_COLLATERAL_FACTOR_VALIDATION, SET_COLLATERAL_FACTOR_WITHOUT_PRICE, SET_IMPLEMENTATION_OWNER_CHECK, SET_LIQUIDATION_INCENTIVE_OWNER_CHECK, SET_LIQUIDATION_INCENTIVE_VALIDATION, SET_MAX_ASSETS_OWNER_CHECK, SET_PENDING_ADMIN_OWNER_CHECK, SET_PENDING_IMPLEMENTATION_OWNER_CHECK, SET_PRICE_ORACLE_OWNER_CHECK, SUPPORT_MARKET_EXISTS, SUPPORT_MARKET_OWNER_CHECK, SET_PAUSE_GUARDIAN_OWNER_CHECK } /** * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary * contract-specific code that enables us to report opaque error codes from upgradeable contracts. **/ event Failure(uint error, uint info, uint detail); /** * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator */ function fail(Error err, FailureInfo info) internal returns (uint) { emit Failure(uint(err), uint(info), 0); return uint(err); } /** * @dev use this when reporting an opaque error from an upgradeable collaborator contract */ function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) { emit Failure(uint(err), uint(info), opaqueError); return uint(err); } } contract TokenErrorReporter { enum Error { NO_ERROR, UNAUTHORIZED, BAD_INPUT, COMPTROLLER_REJECTION, COMPTROLLER_CALCULATION_ERROR, INTEREST_RATE_MODEL_ERROR, INVALID_ACCOUNT_PAIR, INVALID_CLOSE_AMOUNT_REQUESTED, INVALID_COLLATERAL_FACTOR, MATH_ERROR, MARKET_NOT_FRESH, MARKET_NOT_LISTED, TOKEN_INSUFFICIENT_ALLOWANCE, TOKEN_INSUFFICIENT_BALANCE, TOKEN_INSUFFICIENT_CASH, TOKEN_TRANSFER_IN_FAILED, TOKEN_TRANSFER_OUT_FAILED } /* * Note: FailureInfo (but not Error) is kept in alphabetical order * This is because FailureInfo grows significantly faster, and * the order of Error has some meaning, while the order of FailureInfo * is entirely arbitrary. */ enum FailureInfo { ACCEPT_ADMIN_PENDING_ADMIN_CHECK, ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, ACCRUE_INTEREST_BORROW_RATE_CALCULATION_FAILED, ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, BORROW_ACCRUE_INTEREST_FAILED, BORROW_CASH_NOT_AVAILABLE, BORROW_FRESHNESS_CHECK, BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, BORROW_MARKET_NOT_LISTED, BORROW_COMPTROLLER_REJECTION, LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED, LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED, LIQUIDATE_COLLATERAL_FRESHNESS_CHECK, LIQUIDATE_COMPTROLLER_REJECTION, LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED, LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX, LIQUIDATE_CLOSE_AMOUNT_IS_ZERO, LIQUIDATE_FRESHNESS_CHECK, LIQUIDATE_LIQUIDATOR_IS_BORROWER, LIQUIDATE_REPAY_BORROW_FRESH_FAILED, LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, LIQUIDATE_SEIZE_COMPTROLLER_REJECTION, LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER, LIQUIDATE_SEIZE_TOO_MUCH, MINT_ACCRUE_INTEREST_FAILED, MINT_COMPTROLLER_REJECTION, MINT_EXCHANGE_CALCULATION_FAILED, MINT_EXCHANGE_RATE_READ_FAILED, MINT_FRESHNESS_CHECK, MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, MINT_TRANSFER_IN_FAILED, MINT_TRANSFER_IN_NOT_POSSIBLE, REDEEM_ACCRUE_INTEREST_FAILED, REDEEM_COMPTROLLER_REJECTION, REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, REDEEM_EXCHANGE_RATE_READ_FAILED, REDEEM_FRESHNESS_CHECK, REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, REDEEM_TRANSFER_OUT_NOT_POSSIBLE, REDUCE_RESERVES_ACCRUE_INTEREST_FAILED, REDUCE_RESERVES_ADMIN_CHECK, REDUCE_RESERVES_CASH_NOT_AVAILABLE, REDUCE_RESERVES_FRESH_CHECK, REDUCE_RESERVES_VALIDATION, REPAY_BEHALF_ACCRUE_INTEREST_FAILED, REPAY_BORROW_ACCRUE_INTEREST_FAILED, REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, REPAY_BORROW_COMPTROLLER_REJECTION, REPAY_BORROW_FRESHNESS_CHECK, REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, REPAY_BORROW_TRANSFER_IN_NOT_POSSIBLE, SET_COLLATERAL_FACTOR_OWNER_CHECK, SET_COLLATERAL_FACTOR_VALIDATION, SET_COMPTROLLER_OWNER_CHECK, SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED, SET_INTEREST_RATE_MODEL_FRESH_CHECK, SET_INTEREST_RATE_MODEL_OWNER_CHECK, SET_MAX_ASSETS_OWNER_CHECK, SET_ORACLE_MARKET_NOT_LISTED, SET_PENDING_ADMIN_OWNER_CHECK, SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED, SET_RESERVE_FACTOR_ADMIN_CHECK, SET_RESERVE_FACTOR_FRESH_CHECK, SET_RESERVE_FACTOR_BOUNDS_CHECK, TRANSFER_COMPTROLLER_REJECTION, TRANSFER_NOT_ALLOWED, TRANSFER_NOT_ENOUGH, TRANSFER_TOO_MUCH, ADD_RESERVES_ACCRUE_INTEREST_FAILED, ADD_RESERVES_FRESH_CHECK, ADD_RESERVES_TRANSFER_IN_NOT_POSSIBLE } /** * @dev `error` corresponds to enum Error; `info` corresponds to enum FailureInfo, and `detail` is an arbitrary * contract-specific code that enables us to report opaque error codes from upgradeable contracts. **/ event Failure(uint error, uint info, uint detail); /** * @dev use this when reporting a known error from the money market or a non-upgradeable collaborator */ function fail(Error err, FailureInfo info) internal returns (uint) { emit Failure(uint(err), uint(info), 0); return uint(err); } /** * @dev use this when reporting an opaque error from an upgradeable collaborator contract */ function failOpaque(Error err, FailureInfo info, uint opaqueError) internal returns (uint) { emit Failure(uint(err), uint(info), opaqueError); return uint(err); } } // File: contracts/CarefulMath.sol pragma solidity ^0.5.16; /** * @title Careful Math * @author Compound * @notice Derived from OpenZeppelin's SafeMath library * https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/math/SafeMath.sol */ contract CarefulMath { /** * @dev Possible error codes that we can return */ enum MathError { NO_ERROR, DIVISION_BY_ZERO, INTEGER_OVERFLOW, INTEGER_UNDERFLOW } /** * @dev Multiplies two numbers, returns an error on overflow. */ function mulUInt(uint a, uint b) internal pure returns (MathError, uint) { if (a == 0) { return (MathError.NO_ERROR, 0); } uint c = a * b; if (c / a != b) { return (MathError.INTEGER_OVERFLOW, 0); } else { return (MathError.NO_ERROR, c); } } /** * @dev Integer division of two numbers, truncating the quotient. */ function divUInt(uint a, uint b) internal pure returns (MathError, uint) { if (b == 0) { return (MathError.DIVISION_BY_ZERO, 0); } return (MathError.NO_ERROR, a / b); } /** * @dev Subtracts two numbers, returns an error on overflow (i.e. if subtrahend is greater than minuend). */ function subUInt(uint a, uint b) internal pure returns (MathError, uint) { if (b <= a) { return (MathError.NO_ERROR, a - b); } else { return (MathError.INTEGER_UNDERFLOW, 0); } } /** * @dev Adds two numbers, returns an error on overflow. */ function addUInt(uint a, uint b) internal pure returns (MathError, uint) { uint c = a + b; if (c >= a) { return (MathError.NO_ERROR, c); } else { return (MathError.INTEGER_OVERFLOW, 0); } } /** * @dev add a and b and then subtract c */ function addThenSubUInt(uint a, uint b, uint c) internal pure returns (MathError, uint) { (MathError err0, uint sum) = addUInt(a, b); if (err0 != MathError.NO_ERROR) { return (err0, 0); } return subUInt(sum, c); } } // File: contracts/Exponential.sol pragma solidity ^0.5.16; /** * @title Exponential module for storing fixed-precision decimals * @author Compound * @notice Exp is a struct which stores decimals with a fixed precision of 18 decimal places. * Thus, if we wanted to store the 5.1, mantissa would store 5.1e18. That is: * `Exp({mantissa: 5100000000000000000})`. */ contract Exponential is CarefulMath { uint constant expScale = 1e18; uint constant doubleScale = 1e36; uint constant halfExpScale = expScale/2; uint constant mantissaOne = expScale; struct Exp { uint mantissa; } struct Double { uint mantissa; } /** * @dev Creates an exponential from numerator and denominator values. * Note: Returns an error if (`num` * 10e18) > MAX_INT, * or if `denom` is zero. */ function getExp(uint num, uint denom) pure internal returns (MathError, Exp memory) { (MathError err0, uint scaledNumerator) = mulUInt(num, expScale); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } (MathError err1, uint rational) = divUInt(scaledNumerator, denom); if (err1 != MathError.NO_ERROR) { return (err1, Exp({mantissa: 0})); } return (MathError.NO_ERROR, Exp({mantissa: rational})); } /** * @dev Adds two exponentials, returning a new exponential. */ function addExp(Exp memory a, Exp memory b) pure internal returns (MathError, Exp memory) { (MathError error, uint result) = addUInt(a.mantissa, b.mantissa); return (error, Exp({mantissa: result})); } /** * @dev Subtracts two exponentials, returning a new exponential. */ function subExp(Exp memory a, Exp memory b) pure internal returns (MathError, Exp memory) { (MathError error, uint result) = subUInt(a.mantissa, b.mantissa); return (error, Exp({mantissa: result})); } /** * @dev Multiply an Exp by a scalar, returning a new Exp. */ function mulScalar(Exp memory a, uint scalar) pure internal returns (MathError, Exp memory) { (MathError err0, uint scaledMantissa) = mulUInt(a.mantissa, scalar); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } return (MathError.NO_ERROR, Exp({mantissa: scaledMantissa})); } /** * @dev Multiply an Exp by a scalar, then truncate to return an unsigned integer. */ function mulScalarTruncate(Exp memory a, uint scalar) pure internal returns (MathError, uint) { (MathError err, Exp memory product) = mulScalar(a, scalar); if (err != MathError.NO_ERROR) { return (err, 0); } return (MathError.NO_ERROR, truncate(product)); } /** * @dev Multiply an Exp by a scalar, truncate, then add an to an unsigned integer, returning an unsigned integer. */ function mulScalarTruncateAddUInt(Exp memory a, uint scalar, uint addend) pure internal returns (MathError, uint) { (MathError err, Exp memory product) = mulScalar(a, scalar); if (err != MathError.NO_ERROR) { return (err, 0); } return addUInt(truncate(product), addend); } /** * @dev Divide an Exp by a scalar, returning a new Exp. */ function divScalar(Exp memory a, uint scalar) pure internal returns (MathError, Exp memory) { (MathError err0, uint descaledMantissa) = divUInt(a.mantissa, scalar); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } return (MathError.NO_ERROR, Exp({mantissa: descaledMantissa})); } /** * @dev Divide a scalar by an Exp, returning a new Exp. */ function divScalarByExp(uint scalar, Exp memory divisor) pure internal returns (MathError, Exp memory) { /* We are doing this as: getExp(mulUInt(expScale, scalar), divisor.mantissa) How it works: Exp = a / b; Scalar = s; `s / (a / b)` = `b * s / a` and since for an Exp `a = mantissa, b = expScale` */ (MathError err0, uint numerator) = mulUInt(expScale, scalar); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } return getExp(numerator, divisor.mantissa); } /** * @dev Divide a scalar by an Exp, then truncate to return an unsigned integer. */ function divScalarByExpTruncate(uint scalar, Exp memory divisor) pure internal returns (MathError, uint) { (MathError err, Exp memory fraction) = divScalarByExp(scalar, divisor); if (err != MathError.NO_ERROR) { return (err, 0); } return (MathError.NO_ERROR, truncate(fraction)); } /** * @dev Multiplies two exponentials, returning a new exponential. */ function mulExp(Exp memory a, Exp memory b) pure internal returns (MathError, Exp memory) { (MathError err0, uint doubleScaledProduct) = mulUInt(a.mantissa, b.mantissa); if (err0 != MathError.NO_ERROR) { return (err0, Exp({mantissa: 0})); } // We add half the scale before dividing so that we get rounding instead of truncation. // See "Listing 6" and text above it at https://accu.org/index.php/journals/1717 // Without this change, a result like 6.6...e-19 will be truncated to 0 instead of being rounded to 1e-18. (MathError err1, uint doubleScaledProductWithHalfScale) = addUInt(halfExpScale, doubleScaledProduct); if (err1 != MathError.NO_ERROR) { return (err1, Exp({mantissa: 0})); } (MathError err2, uint product) = divUInt(doubleScaledProductWithHalfScale, expScale); // The only error `div` can return is MathError.DIVISION_BY_ZERO but we control `expScale` and it is not zero. assert(err2 == MathError.NO_ERROR); return (MathError.NO_ERROR, Exp({mantissa: product})); } /** * @dev Multiplies two exponentials given their mantissas, returning a new exponential. */ function mulExp(uint a, uint b) pure internal returns (MathError, Exp memory) { return mulExp(Exp({mantissa: a}), Exp({mantissa: b})); } /** * @dev Multiplies three exponentials, returning a new exponential. */ function mulExp3(Exp memory a, Exp memory b, Exp memory c) pure internal returns (MathError, Exp memory) { (MathError err, Exp memory ab) = mulExp(a, b); if (err != MathError.NO_ERROR) { return (err, ab); } return mulExp(ab, c); } /** * @dev Divides two exponentials, returning a new exponential. * (a/scale) / (b/scale) = (a/scale) * (scale/b) = a/b, * which we can scale as an Exp by calling getExp(a.mantissa, b.mantissa) */ function divExp(Exp memory a, Exp memory b) pure internal returns (MathError, Exp memory) { return getExp(a.mantissa, b.mantissa); } /** * @dev Truncates the given exp to a whole number value. * For example, truncate(Exp{mantissa: 15 * expScale}) = 15 */ function truncate(Exp memory exp) pure internal returns (uint) { // Note: We are not using careful math here as we're performing a division that cannot fail return exp.mantissa / expScale; } /** * @dev Checks if first Exp is less than second Exp. */ function lessThanExp(Exp memory left, Exp memory right) pure internal returns (bool) { return left.mantissa < right.mantissa; } /** * @dev Checks if left Exp <= right Exp. */ function lessThanOrEqualExp(Exp memory left, Exp memory right) pure internal returns (bool) { return left.mantissa <= right.mantissa; } /** * @dev Checks if left Exp > right Exp. */ function greaterThanExp(Exp memory left, Exp memory right) pure internal returns (bool) { return left.mantissa > right.mantissa; } /** * @dev returns true if Exp is exactly zero */ function isZeroExp(Exp memory value) pure internal returns (bool) { return value.mantissa == 0; } function safe224(uint n, string memory errorMessage) pure internal returns (uint224) { require(n < 2**224, errorMessage); return uint224(n); } function safe32(uint n, string memory errorMessage) pure internal returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function add_(Exp memory a, Exp memory b) pure internal returns (Exp memory) { return Exp({mantissa: add_(a.mantissa, b.mantissa)}); } function add_(Double memory a, Double memory b) pure internal returns (Double memory) { return Double({mantissa: add_(a.mantissa, b.mantissa)}); } function add_(uint a, uint b) pure internal returns (uint) { return add_(a, b, "addition overflow"); } function add_(uint a, uint b, string memory errorMessage) pure internal returns (uint) { uint c = a + b; require(c >= a, errorMessage); return c; } function sub_(Exp memory a, Exp memory b) pure internal returns (Exp memory) { return Exp({mantissa: sub_(a.mantissa, b.mantissa)}); } function sub_(Double memory a, Double memory b) pure internal returns (Double memory) { return Double({mantissa: sub_(a.mantissa, b.mantissa)}); } function sub_(uint a, uint b) pure internal returns (uint) { return sub_(a, b, "subtraction underflow"); } function sub_(uint a, uint b, string memory errorMessage) pure internal returns (uint) { require(b <= a, errorMessage); return a - b; } function mul_(Exp memory a, Exp memory b) pure internal returns (Exp memory) { return Exp({mantissa: mul_(a.mantissa, b.mantissa) / expScale}); } function mul_(Exp memory a, uint b) pure internal returns (Exp memory) { return Exp({mantissa: mul_(a.mantissa, b)}); } function mul_(uint a, Exp memory b) pure internal returns (uint) { return mul_(a, b.mantissa) / expScale; } function mul_(Double memory a, Double memory b) pure internal returns (Double memory) { return Double({mantissa: mul_(a.mantissa, b.mantissa) / doubleScale}); } function mul_(Double memory a, uint b) pure internal returns (Double memory) { return Double({mantissa: mul_(a.mantissa, b)}); } function mul_(uint a, Double memory b) pure internal returns (uint) { return mul_(a, b.mantissa) / doubleScale; } function mul_(uint a, uint b) pure internal returns (uint) { return mul_(a, b, "multiplication overflow"); } function mul_(uint a, uint b, string memory errorMessage) pure internal returns (uint) { if (a == 0 || b == 0) { return 0; } uint c = a * b; require(c / a == b, errorMessage); return c; } function div_(Exp memory a, Exp memory b) pure internal returns (Exp memory) { return Exp({mantissa: div_(mul_(a.mantissa, expScale), b.mantissa)}); } function div_(Exp memory a, uint b) pure internal returns (Exp memory) { return Exp({mantissa: div_(a.mantissa, b)}); } function div_(uint a, Exp memory b) pure internal returns (uint) { return div_(mul_(a, expScale), b.mantissa); } function div_(Double memory a, Double memory b) pure internal returns (Double memory) { return Double({mantissa: div_(mul_(a.mantissa, doubleScale), b.mantissa)}); } function div_(Double memory a, uint b) pure internal returns (Double memory) { return Double({mantissa: div_(a.mantissa, b)}); } function div_(uint a, Double memory b) pure internal returns (uint) { return div_(mul_(a, doubleScale), b.mantissa); } function div_(uint a, uint b) pure internal returns (uint) { return div_(a, b, "divide by zero"); } function div_(uint a, uint b, string memory errorMessage) pure internal returns (uint) { require(b > 0, errorMessage); return a / b; } function fraction(uint a, uint b) pure internal returns (Double memory) { return Double({mantissa: div_(mul_(a, doubleScale), b)}); } } // File: contracts/EIP20Interface.sol pragma solidity ^0.5.16; /** * @title ERC 20 Token Standard Interface * https://eips.ethereum.org/EIPS/eip-20 */ interface EIP20Interface { function name() external view returns (string memory); function symbol() external view returns (string memory); function decimals() external view returns (uint8); /** * @notice Get the total number of tokens in circulation * @return The supply of tokens */ function totalSupply() external view returns (uint256); /** * @notice Gets the balance of the specified address * @param owner The address from which the balance will be retrieved * @return The balance */ function balanceOf(address owner) external view returns (uint256 balance); /** * @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, uint256 amount) external returns (bool success); /** * @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, uint256 amount) external returns (bool success); /** * @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 (-1 means infinite) * @return Whether or not the approval succeeded */ function approve(address spender, uint256 amount) external returns (bool success); /** * @notice Get the current allowance from `owner` for `spender` * @param owner The address of the account which owns the tokens to be spent * @param spender The address of the account which may transfer tokens * @return The number of tokens allowed to be spent (-1 means infinite) */ function allowance(address owner, address spender) external view returns (uint256 remaining); event Transfer(address indexed from, address indexed to, uint256 amount); event Approval(address indexed owner, address indexed spender, uint256 amount); } // File: contracts/EIP20NonStandardInterface.sol pragma solidity ^0.5.16; /** * @title EIP20NonStandardInterface * @dev Version of ERC20 with no return values for `transfer` and `transferFrom` * See https://medium.com/coinmonks/missing-return-value-bug-at-least-130-tokens-affected-d67bf08521ca */ interface EIP20NonStandardInterface { /** * @notice Get the total number of tokens in circulation * @return The supply of tokens */ function totalSupply() external view returns (uint256); /** * @notice Gets the balance of the specified address * @param owner The address from which the balance will be retrieved * @return The balance */ function balanceOf(address owner) external view returns (uint256 balance); /// /// !!!!!!!!!!!!!! /// !!! NOTICE !!! `transfer` does not return a value, in violation of the ERC-20 specification /// !!!!!!!!!!!!!! /// /** * @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 */ function transfer(address dst, uint256 amount) external; /// /// !!!!!!!!!!!!!! /// !!! NOTICE !!! `transferFrom` does not return a value, in violation of the ERC-20 specification /// !!!!!!!!!!!!!! /// /** * @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 */ function transferFrom(address src, address dst, uint256 amount) external; /** * @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 * @return Whether or not the approval succeeded */ function approve(address spender, uint256 amount) external returns (bool success); /** * @notice Get the current allowance from `owner` for `spender` * @param owner The address of the account which owns the tokens to be spent * @param spender The address of the account which may transfer tokens * @return The number of tokens allowed to be spent */ function allowance(address owner, address spender) external view returns (uint256 remaining); event Transfer(address indexed from, address indexed to, uint256 amount); event Approval(address indexed owner, address indexed spender, uint256 amount); } // File: contracts/CToken.sol pragma solidity ^0.5.16; /** * @title Compound's CToken Contract * @notice Abstract base for CTokens * @author Compound */ contract CToken is CTokenInterface, Exponential, TokenErrorReporter { /** * @notice Initialize the money market * @param comptroller_ The address of the Comptroller * @param interestRateModel_ The address of the interest rate model * @param initialExchangeRateMantissa_ The initial exchange rate, scaled by 1e18 * @param name_ EIP-20 name of this token * @param symbol_ EIP-20 symbol of this token * @param decimals_ EIP-20 decimal precision of this token */ function initialize(ComptrollerInterface comptroller_, InterestRateModel interestRateModel_, uint initialExchangeRateMantissa_, string memory name_, string memory symbol_, uint8 decimals_) public { require(msg.sender == admin, "only admin may initialize the market"); require(accrualBlockNumber == 0 && borrowIndex == 0, "market may only be initialized once"); // Set initial exchange rate initialExchangeRateMantissa = initialExchangeRateMantissa_; require(initialExchangeRateMantissa > 0, "initial exchange rate must be greater than zero."); // Set the comptroller uint err = _setComptroller(comptroller_); require(err == uint(Error.NO_ERROR), "setting comptroller failed"); // Initialize block number and borrow index (block number mocks depend on comptroller being set) accrualBlockNumber = getBlockNumber(); borrowIndex = mantissaOne; // Set the interest rate model (depends on block number / borrow index) err = _setInterestRateModelFresh(interestRateModel_); require(err == uint(Error.NO_ERROR), "setting interest rate model failed"); name = name_; symbol = symbol_; decimals = decimals_; // The counter starts true to prevent changing it from zero to non-zero (i.e. smaller cost/refund) _notEntered = true; } /** * @notice Transfer `tokens` tokens from `src` to `dst` by `spender` * @dev Called by both `transfer` and `transferFrom` internally * @param spender The address of the account performing the transfer * @param src The address of the source account * @param dst The address of the destination account * @param tokens The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transferTokens(address spender, address src, address dst, uint tokens) internal returns (uint) { /* Fail if transfer not allowed */ uint allowed = comptroller.transferAllowed(address(this), src, dst, tokens); if (allowed != 0) { return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.TRANSFER_COMPTROLLER_REJECTION, allowed); } /* Do not allow self-transfers */ if (src == dst) { return fail(Error.BAD_INPUT, FailureInfo.TRANSFER_NOT_ALLOWED); } /* Get the allowance, infinite for the account owner */ uint startingAllowance = 0; if (spender == src) { startingAllowance = uint(-1); } else { startingAllowance = transferAllowances[src][spender]; } /* Do the calculations, checking for {under,over}flow */ MathError mathErr; uint allowanceNew; uint srcTokensNew; uint dstTokensNew; (mathErr, allowanceNew) = subUInt(startingAllowance, tokens); if (mathErr != MathError.NO_ERROR) { return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ALLOWED); } (mathErr, srcTokensNew) = subUInt(accountTokens[src], tokens); if (mathErr != MathError.NO_ERROR) { return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_NOT_ENOUGH); } (mathErr, dstTokensNew) = addUInt(accountTokens[dst], tokens); if (mathErr != MathError.NO_ERROR) { return fail(Error.MATH_ERROR, FailureInfo.TRANSFER_TOO_MUCH); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) accountTokens[src] = srcTokensNew; accountTokens[dst] = dstTokensNew; /* Eat some of the allowance (if necessary) */ if (startingAllowance != uint(-1)) { transferAllowances[src][spender] = allowanceNew; } /* We emit a Transfer event */ emit Transfer(src, dst, tokens); comptroller.transferVerify(address(this), src, dst, tokens); return uint(Error.NO_ERROR); } /** * @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, uint256 amount) external nonReentrant returns (bool) { return transferTokens(msg.sender, msg.sender, dst, amount) == uint(Error.NO_ERROR); } /** * @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, uint256 amount) external nonReentrant returns (bool) { return transferTokens(msg.sender, src, dst, amount) == uint(Error.NO_ERROR); } /** * @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 (-1 means infinite) * @return Whether or not the approval succeeded */ function approve(address spender, uint256 amount) external returns (bool) { address src = msg.sender; transferAllowances[src][spender] = amount; emit Approval(src, spender, amount); return true; } /** * @notice Get the current allowance from `owner` for `spender` * @param owner The address of the account which owns the tokens to be spent * @param spender The address of the account which may transfer tokens * @return The number of tokens allowed to be spent (-1 means infinite) */ function allowance(address owner, address spender) external view returns (uint256) { return transferAllowances[owner][spender]; } /** * @notice Get the token balance of the `owner` * @param owner The address of the account to query * @return The number of tokens owned by `owner` */ function balanceOf(address owner) external view returns (uint256) { return accountTokens[owner]; } /** * @notice Get the underlying balance of the `owner` * @dev This also accrues interest in a transaction * @param owner The address of the account to query * @return The amount of underlying owned by `owner` */ function balanceOfUnderlying(address owner) external returns (uint) { Exp memory exchangeRate = Exp({mantissa: exchangeRateCurrent()}); (MathError mErr, uint balance) = mulScalarTruncate(exchangeRate, accountTokens[owner]); require(mErr == MathError.NO_ERROR, "balance could not be calculated"); return balance; } /** * @notice Get a snapshot of the account's balances, and the cached exchange rate * @dev This is used by comptroller to more efficiently perform liquidity checks. * @param account Address of the account to snapshot * @return (possible error, token balance, borrow balance, exchange rate mantissa) */ function getAccountSnapshot(address account) external view returns (uint, uint, uint, uint) { uint cTokenBalance = accountTokens[account]; uint borrowBalance; uint exchangeRateMantissa; MathError mErr; (mErr, borrowBalance) = borrowBalanceStoredInternal(account); if (mErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0, 0, 0); } (mErr, exchangeRateMantissa) = exchangeRateStoredInternal(); if (mErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0, 0, 0); } return (uint(Error.NO_ERROR), cTokenBalance, borrowBalance, exchangeRateMantissa); } /** * @dev Function to simply retrieve block number * This exists mainly for inheriting test contracts to stub this result. */ function getBlockNumber() internal view returns (uint) { return block.number; } /** * @notice Returns the current per-block borrow interest rate for this cToken * @return The borrow interest rate per block, scaled by 1e18 */ function borrowRatePerBlock() external view returns (uint) { return interestRateModel.getBorrowRate(getCashPrior(), totalBorrows, totalReserves); } /** * @notice Returns the current per-block supply interest rate for this cToken * @return The supply interest rate per block, scaled by 1e18 */ function supplyRatePerBlock() external view returns (uint) { return interestRateModel.getSupplyRate(getCashPrior(), totalBorrows, totalReserves, reserveFactorMantissa); } /** * @notice Returns the current total borrows plus accrued interest * @return The total borrows with interest */ function totalBorrowsCurrent() external nonReentrant returns (uint) { require(accrueInterest() == uint(Error.NO_ERROR), "accrue interest failed"); return totalBorrows; } /** * @notice Accrue interest to updated borrowIndex and then calculate account's borrow balance using the updated borrowIndex * @param account The address whose balance should be calculated after updating borrowIndex * @return The calculated balance */ function borrowBalanceCurrent(address account) external nonReentrant returns (uint) { require(accrueInterest() == uint(Error.NO_ERROR), "accrue interest failed"); return borrowBalanceStored(account); } /** * @notice Return the borrow balance of account based on stored data * @param account The address whose balance should be calculated * @return The calculated balance */ function borrowBalanceStored(address account) public view returns (uint) { (MathError err, uint result) = borrowBalanceStoredInternal(account); require(err == MathError.NO_ERROR, "borrowBalanceStored: borrowBalanceStoredInternal failed"); return result; } /** * @notice Return the borrow balance of account based on stored data * @param account The address whose balance should be calculated * @return (error code, the calculated balance or 0 if error code is non-zero) */ function borrowBalanceStoredInternal(address account) internal view returns (MathError, uint) { /* Note: we do not assert that the market is up to date */ MathError mathErr; uint principalTimesIndex; uint result; /* Get borrowBalance and borrowIndex */ BorrowSnapshot storage borrowSnapshot = accountBorrows[account]; /* If borrowBalance = 0 then borrowIndex is likely also 0. * Rather than failing the calculation with a division by 0, we immediately return 0 in this case. */ if (borrowSnapshot.principal == 0) { return (MathError.NO_ERROR, 0); } /* Calculate new borrow balance using the interest index: * recentBorrowBalance = borrower.borrowBalance * market.borrowIndex / borrower.borrowIndex */ (mathErr, principalTimesIndex) = mulUInt(borrowSnapshot.principal, borrowIndex); if (mathErr != MathError.NO_ERROR) { return (mathErr, 0); } (mathErr, result) = divUInt(principalTimesIndex, borrowSnapshot.interestIndex); if (mathErr != MathError.NO_ERROR) { return (mathErr, 0); } return (MathError.NO_ERROR, result); } /** * @notice Accrue interest then return the up-to-date exchange rate * @return Calculated exchange rate scaled by 1e18 */ function exchangeRateCurrent() public nonReentrant returns (uint) { require(accrueInterest() == uint(Error.NO_ERROR), "accrue interest failed"); return exchangeRateStored(); } /** * @notice Calculates the exchange rate from the underlying to the CToken * @dev This function does not accrue interest before calculating the exchange rate * @return Calculated exchange rate scaled by 1e18 */ function exchangeRateStored() public view returns (uint) { (MathError err, uint result) = exchangeRateStoredInternal(); require(err == MathError.NO_ERROR, "exchangeRateStored: exchangeRateStoredInternal failed"); return result; } /** * @notice Calculates the exchange rate from the underlying to the CToken * @dev This function does not accrue interest before calculating the exchange rate * @return (error code, calculated exchange rate scaled by 1e18) */ function exchangeRateStoredInternal() internal view returns (MathError, uint) { uint _totalSupply = totalSupply; if (_totalSupply == 0) { /* * If there are no tokens minted: * exchangeRate = initialExchangeRate */ return (MathError.NO_ERROR, initialExchangeRateMantissa); } else { /* * Otherwise: * exchangeRate = (totalCash + totalBorrows - totalReserves) / totalSupply */ uint totalCash = getCashPrior(); uint cashPlusBorrowsMinusReserves; Exp memory exchangeRate; MathError mathErr; (mathErr, cashPlusBorrowsMinusReserves) = addThenSubUInt(totalCash, totalBorrows, totalReserves); if (mathErr != MathError.NO_ERROR) { return (mathErr, 0); } (mathErr, exchangeRate) = getExp(cashPlusBorrowsMinusReserves, _totalSupply); if (mathErr != MathError.NO_ERROR) { return (mathErr, 0); } return (MathError.NO_ERROR, exchangeRate.mantissa); } } /** * @notice Get cash balance of this cToken in the underlying asset * @return The quantity of underlying asset owned by this contract */ function getCash() external view returns (uint) { return getCashPrior(); } /** * @notice Applies accrued interest to total borrows and reserves * @dev This calculates interest accrued from the last checkpointed block * up to the current block and writes new checkpoint to storage. */ function accrueInterest() public returns (uint) { /* Remember the initial block number */ uint currentBlockNumber = getBlockNumber(); uint accrualBlockNumberPrior = accrualBlockNumber; /* Short-circuit accumulating 0 interest */ if (accrualBlockNumberPrior == currentBlockNumber) { return uint(Error.NO_ERROR); } /* Read the previous values out of storage */ uint cashPrior = getCashPrior(); uint borrowsPrior = totalBorrows; uint reservesPrior = totalReserves; uint borrowIndexPrior = borrowIndex; /* Calculate the current borrow interest rate */ uint borrowRateMantissa = interestRateModel.getBorrowRate(cashPrior, borrowsPrior, reservesPrior); require(borrowRateMantissa <= borrowRateMaxMantissa, "borrow rate is absurdly high"); /* Calculate the number of blocks elapsed since the last accrual */ (MathError mathErr, uint blockDelta) = subUInt(currentBlockNumber, accrualBlockNumberPrior); require(mathErr == MathError.NO_ERROR, "could not calculate block delta"); /* * Calculate the interest accumulated into borrows and reserves and the new index: * simpleInterestFactor = borrowRate * blockDelta * interestAccumulated = simpleInterestFactor * totalBorrows * totalBorrowsNew = interestAccumulated + totalBorrows * totalReservesNew = interestAccumulated * reserveFactor + totalReserves * borrowIndexNew = simpleInterestFactor * borrowIndex + borrowIndex */ Exp memory simpleInterestFactor; uint interestAccumulated; uint totalBorrowsNew; uint totalReservesNew; uint borrowIndexNew; (mathErr, simpleInterestFactor) = mulScalar(Exp({mantissa: borrowRateMantissa}), blockDelta); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_SIMPLE_INTEREST_FACTOR_CALCULATION_FAILED, uint(mathErr)); } (mathErr, interestAccumulated) = mulScalarTruncate(simpleInterestFactor, borrowsPrior); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_ACCUMULATED_INTEREST_CALCULATION_FAILED, uint(mathErr)); } (mathErr, totalBorrowsNew) = addUInt(interestAccumulated, borrowsPrior); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_BORROWS_CALCULATION_FAILED, uint(mathErr)); } (mathErr, totalReservesNew) = mulScalarTruncateAddUInt(Exp({mantissa: reserveFactorMantissa}), interestAccumulated, reservesPrior); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_TOTAL_RESERVES_CALCULATION_FAILED, uint(mathErr)); } (mathErr, borrowIndexNew) = mulScalarTruncateAddUInt(simpleInterestFactor, borrowIndexPrior, borrowIndexPrior); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.ACCRUE_INTEREST_NEW_BORROW_INDEX_CALCULATION_FAILED, uint(mathErr)); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* We write the previously calculated values into storage */ accrualBlockNumber = currentBlockNumber; borrowIndex = borrowIndexNew; totalBorrows = totalBorrowsNew; totalReserves = totalReservesNew; /* We emit an AccrueInterest event */ emit AccrueInterest(cashPrior, interestAccumulated, borrowIndexNew, totalBorrowsNew); return uint(Error.NO_ERROR); } /** * @notice Sender supplies assets into the market and receives cTokens in exchange * @dev Accrues interest whether or not the operation succeeds, unless reverted * @param mintAmount The amount of the underlying asset to supply * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount. */ function mintInternal(uint mintAmount) internal nonReentrant returns (uint, uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed return (fail(Error(error), FailureInfo.MINT_ACCRUE_INTEREST_FAILED), 0); } // mintFresh emits the actual Mint event if successful and logs on errors, so we don't need to return mintFresh(msg.sender, mintAmount); } struct MintLocalVars { Error err; MathError mathErr; uint exchangeRateMantissa; uint mintTokens; uint totalSupplyNew; uint accountTokensNew; uint actualMintAmount; } /** * @notice User supplies assets into the market and receives cTokens in exchange * @dev Assumes interest has already been accrued up to the current block * @param minter The address of the account which is supplying the assets * @param mintAmount The amount of the underlying asset to supply * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual mint amount. */ function mintFresh(address minter, uint mintAmount) internal returns (uint, uint) { /* Fail if mint not allowed */ uint allowed = comptroller.mintAllowed(address(this), minter, mintAmount); if (allowed != 0) { return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.MINT_COMPTROLLER_REJECTION, allowed), 0); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.MINT_FRESHNESS_CHECK), 0); } MintLocalVars memory vars; (vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal(); if (vars.mathErr != MathError.NO_ERROR) { return (failOpaque(Error.MATH_ERROR, FailureInfo.MINT_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)), 0); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We call `doTransferIn` for the minter and the mintAmount. * Note: The cToken must handle variations between ERC-20 and ETH underlying. * `doTransferIn` reverts if anything goes wrong, since we can't be sure if * side-effects occurred. The function returns the amount actually transferred, * in case of a fee. On success, the cToken holds an additional `actualMintAmount` * of cash. */ vars.actualMintAmount = doTransferIn(minter, mintAmount); /* * We get the current exchange rate and calculate the number of cTokens to be minted: * mintTokens = actualMintAmount / exchangeRate */ (vars.mathErr, vars.mintTokens) = divScalarByExpTruncate(vars.actualMintAmount, Exp({mantissa: vars.exchangeRateMantissa})); require(vars.mathErr == MathError.NO_ERROR, "MINT_EXCHANGE_CALCULATION_FAILED"); /* * We calculate the new total supply of cTokens and minter token balance, checking for overflow: * totalSupplyNew = totalSupply + mintTokens * accountTokensNew = accountTokens[minter] + mintTokens */ (vars.mathErr, vars.totalSupplyNew) = addUInt(totalSupply, vars.mintTokens); require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_TOTAL_SUPPLY_CALCULATION_FAILED"); (vars.mathErr, vars.accountTokensNew) = addUInt(accountTokens[minter], vars.mintTokens); require(vars.mathErr == MathError.NO_ERROR, "MINT_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED"); /* We write previously calculated values into storage */ totalSupply = vars.totalSupplyNew; accountTokens[minter] = vars.accountTokensNew; /* We emit a Mint event, and a Transfer event */ emit Mint(minter, vars.actualMintAmount, vars.mintTokens); emit Transfer(address(this), minter, vars.mintTokens); /* We call the defense hook */ comptroller.mintVerify(address(this), minter, vars.actualMintAmount, vars.mintTokens); return (uint(Error.NO_ERROR), vars.actualMintAmount); } /** * @notice Sender redeems cTokens in exchange for the underlying asset * @dev Accrues interest whether or not the operation succeeds, unless reverted * @param redeemTokens The number of cTokens to redeem into underlying * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function redeemInternal(uint redeemTokens) internal nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted redeem failed return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED); } // redeemFresh emits redeem-specific logs on errors, so we don't need to return redeemFresh(msg.sender, redeemTokens, 0); } /** * @notice Sender redeems cTokens in exchange for a specified amount of underlying asset * @dev Accrues interest whether or not the operation succeeds, unless reverted * @param redeemAmount The amount of underlying to receive from redeeming cTokens * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function redeemUnderlyingInternal(uint redeemAmount) internal nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted redeem failed return fail(Error(error), FailureInfo.REDEEM_ACCRUE_INTEREST_FAILED); } // redeemFresh emits redeem-specific logs on errors, so we don't need to return redeemFresh(msg.sender, 0, redeemAmount); } struct RedeemLocalVars { Error err; MathError mathErr; uint exchangeRateMantissa; uint redeemTokens; uint redeemAmount; uint totalSupplyNew; uint accountTokensNew; } /** * @notice User redeems cTokens in exchange for the underlying asset * @dev Assumes interest has already been accrued up to the current block * @param redeemer The address of the account which is redeeming the tokens * @param redeemTokensIn The number of cTokens to redeem into underlying (only one of redeemTokensIn or redeemAmountIn may be non-zero) * @param redeemAmountIn The number of underlying tokens to receive from redeeming cTokens (only one of redeemTokensIn or redeemAmountIn may be non-zero) * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function redeemFresh(address payable redeemer, uint redeemTokensIn, uint redeemAmountIn) internal returns (uint) { require(redeemTokensIn == 0 || redeemAmountIn == 0, "one of redeemTokensIn or redeemAmountIn must be zero"); RedeemLocalVars memory vars; /* exchangeRate = invoke Exchange Rate Stored() */ (vars.mathErr, vars.exchangeRateMantissa) = exchangeRateStoredInternal(); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_RATE_READ_FAILED, uint(vars.mathErr)); } /* If redeemTokensIn > 0: */ if (redeemTokensIn > 0) { /* * We calculate the exchange rate and the amount of underlying to be redeemed: * redeemTokens = redeemTokensIn * redeemAmount = redeemTokensIn x exchangeRateCurrent */ vars.redeemTokens = redeemTokensIn; (vars.mathErr, vars.redeemAmount) = mulScalarTruncate(Exp({mantissa: vars.exchangeRateMantissa}), redeemTokensIn); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_TOKENS_CALCULATION_FAILED, uint(vars.mathErr)); } } else { /* * We get the current exchange rate and calculate the amount to be redeemed: * redeemTokens = redeemAmountIn / exchangeRate * redeemAmount = redeemAmountIn */ (vars.mathErr, vars.redeemTokens) = divScalarByExpTruncate(redeemAmountIn, Exp({mantissa: vars.exchangeRateMantissa})); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_EXCHANGE_AMOUNT_CALCULATION_FAILED, uint(vars.mathErr)); } vars.redeemAmount = redeemAmountIn; } /* Fail if redeem not allowed */ uint allowed = comptroller.redeemAllowed(address(this), redeemer, vars.redeemTokens); if (allowed != 0) { return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.REDEEM_COMPTROLLER_REJECTION, allowed); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDEEM_FRESHNESS_CHECK); } /* * We calculate the new total supply and redeemer balance, checking for underflow: * totalSupplyNew = totalSupply - redeemTokens * accountTokensNew = accountTokens[redeemer] - redeemTokens */ (vars.mathErr, vars.totalSupplyNew) = subUInt(totalSupply, vars.redeemTokens); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_TOTAL_SUPPLY_CALCULATION_FAILED, uint(vars.mathErr)); } (vars.mathErr, vars.accountTokensNew) = subUInt(accountTokens[redeemer], vars.redeemTokens); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.REDEEM_NEW_ACCOUNT_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)); } /* Fail gracefully if protocol has insufficient cash */ if (getCashPrior() < vars.redeemAmount) { return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDEEM_TRANSFER_OUT_NOT_POSSIBLE); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We invoke doTransferOut for the redeemer and the redeemAmount. * Note: The cToken must handle variations between ERC-20 and ETH underlying. * On success, the cToken has redeemAmount less of cash. * doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred. */ doTransferOut(redeemer, vars.redeemAmount); /* We write previously calculated values into storage */ totalSupply = vars.totalSupplyNew; accountTokens[redeemer] = vars.accountTokensNew; /* We emit a Transfer event, and a Redeem event */ emit Transfer(redeemer, address(this), vars.redeemTokens); emit Redeem(redeemer, vars.redeemAmount, vars.redeemTokens); /* We call the defense hook */ comptroller.redeemVerify(address(this), redeemer, vars.redeemAmount, vars.redeemTokens); return uint(Error.NO_ERROR); } /** * @notice Sender borrows assets from the protocol to their own address * @param borrowAmount The amount of the underlying asset to borrow * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function borrowInternal(uint borrowAmount) internal nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed return fail(Error(error), FailureInfo.BORROW_ACCRUE_INTEREST_FAILED); } // borrowFresh emits borrow-specific logs on errors, so we don't need to return borrowFresh(msg.sender, borrowAmount); } struct BorrowLocalVars { MathError mathErr; uint accountBorrows; uint accountBorrowsNew; uint totalBorrowsNew; } /** * @notice Users borrow assets from the protocol to their own address * @param borrowAmount The amount of the underlying asset to borrow * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function borrowFresh(address payable borrower, uint borrowAmount) internal returns (uint) { /* Fail if borrow not allowed */ uint allowed = comptroller.borrowAllowed(address(this), borrower, borrowAmount); if (allowed != 0) { return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.BORROW_COMPTROLLER_REJECTION, allowed); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.BORROW_FRESHNESS_CHECK); } /* Fail gracefully if protocol has insufficient underlying cash */ if (getCashPrior() < borrowAmount) { return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.BORROW_CASH_NOT_AVAILABLE); } BorrowLocalVars memory vars; /* * We calculate the new borrower and total borrow balances, failing on overflow: * accountBorrowsNew = accountBorrows + borrowAmount * totalBorrowsNew = totalBorrows + borrowAmount */ (vars.mathErr, vars.accountBorrows) = borrowBalanceStoredInternal(borrower); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)); } (vars.mathErr, vars.accountBorrowsNew) = addUInt(vars.accountBorrows, borrowAmount); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)); } (vars.mathErr, vars.totalBorrowsNew) = addUInt(totalBorrows, borrowAmount); if (vars.mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We invoke doTransferOut for the borrower and the borrowAmount. * Note: The cToken must handle variations between ERC-20 and ETH underlying. * On success, the cToken borrowAmount less of cash. * doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred. */ doTransferOut(borrower, borrowAmount); /* We write the previously calculated values into storage */ accountBorrows[borrower].principal = vars.accountBorrowsNew; accountBorrows[borrower].interestIndex = borrowIndex; totalBorrows = vars.totalBorrowsNew; /* We emit a Borrow event */ emit Borrow(borrower, borrowAmount, vars.accountBorrowsNew, vars.totalBorrowsNew); /* We call the defense hook */ comptroller.borrowVerify(address(this), borrower, borrowAmount); return uint(Error.NO_ERROR); } /** * @notice Sender repays their own borrow * @param repayAmount The amount to repay * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function repayBorrowInternal(uint repayAmount) internal nonReentrant returns (uint, uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed return (fail(Error(error), FailureInfo.REPAY_BORROW_ACCRUE_INTEREST_FAILED), 0); } // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to return repayBorrowFresh(msg.sender, msg.sender, repayAmount); } /** * @notice Sender repays a borrow belonging to borrower * @param borrower the account with the debt being payed off * @param repayAmount The amount to repay * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function repayBorrowBehalfInternal(address borrower, uint repayAmount) internal nonReentrant returns (uint, uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted borrow failed return (fail(Error(error), FailureInfo.REPAY_BEHALF_ACCRUE_INTEREST_FAILED), 0); } // repayBorrowFresh emits repay-borrow-specific logs on errors, so we don't need to return repayBorrowFresh(msg.sender, borrower, repayAmount); } struct RepayBorrowLocalVars { Error err; MathError mathErr; uint repayAmount; uint borrowerIndex; uint accountBorrows; uint accountBorrowsNew; uint totalBorrowsNew; uint actualRepayAmount; } /** * @notice Borrows are repaid by another user (possibly the borrower). * @param payer the account paying off the borrow * @param borrower the account with the debt being payed off * @param repayAmount the amount of undelrying tokens being returned * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function repayBorrowFresh(address payer, address borrower, uint repayAmount) internal returns (uint, uint) { /* Fail if repayBorrow not allowed */ uint allowed = comptroller.repayBorrowAllowed(address(this), payer, borrower, repayAmount); if (allowed != 0) { return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.REPAY_BORROW_COMPTROLLER_REJECTION, allowed), 0); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.REPAY_BORROW_FRESHNESS_CHECK), 0); } RepayBorrowLocalVars memory vars; /* We remember the original borrowerIndex for verification purposes */ vars.borrowerIndex = accountBorrows[borrower].interestIndex; /* We fetch the amount the borrower owes, with accumulated interest */ (vars.mathErr, vars.accountBorrows) = borrowBalanceStoredInternal(borrower); if (vars.mathErr != MathError.NO_ERROR) { return (failOpaque(Error.MATH_ERROR, FailureInfo.REPAY_BORROW_ACCUMULATED_BALANCE_CALCULATION_FAILED, uint(vars.mathErr)), 0); } /* If repayAmount == -1, repayAmount = accountBorrows */ if (repayAmount == uint(-1)) { vars.repayAmount = vars.accountBorrows; } else { vars.repayAmount = repayAmount; } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We call doTransferIn for the payer and the repayAmount * Note: The cToken must handle variations between ERC-20 and ETH underlying. * On success, the cToken holds an additional repayAmount of cash. * doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred. * it returns the amount actually transferred, in case of a fee. */ vars.actualRepayAmount = doTransferIn(payer, vars.repayAmount); /* * We calculate the new borrower and total borrow balances, failing on underflow: * accountBorrowsNew = accountBorrows - actualRepayAmount * totalBorrowsNew = totalBorrows - actualRepayAmount */ (vars.mathErr, vars.accountBorrowsNew) = subUInt(vars.accountBorrows, vars.actualRepayAmount); require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_ACCOUNT_BORROW_BALANCE_CALCULATION_FAILED"); (vars.mathErr, vars.totalBorrowsNew) = subUInt(totalBorrows, vars.actualRepayAmount); require(vars.mathErr == MathError.NO_ERROR, "REPAY_BORROW_NEW_TOTAL_BALANCE_CALCULATION_FAILED"); /* We write the previously calculated values into storage */ accountBorrows[borrower].principal = vars.accountBorrowsNew; accountBorrows[borrower].interestIndex = borrowIndex; totalBorrows = vars.totalBorrowsNew; /* We emit a RepayBorrow event */ emit RepayBorrow(payer, borrower, vars.actualRepayAmount, vars.accountBorrowsNew, vars.totalBorrowsNew); /* We call the defense hook */ comptroller.repayBorrowVerify(address(this), payer, borrower, vars.actualRepayAmount, vars.borrowerIndex); return (uint(Error.NO_ERROR), vars.actualRepayAmount); } /** * @notice The sender liquidates the borrowers collateral. * The collateral seized is transferred to the liquidator. * @param borrower The borrower of this cToken to be liquidated * @param cTokenCollateral The market in which to seize collateral from the borrower * @param repayAmount The amount of the underlying borrowed asset to repay * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function liquidateBorrowInternal(address borrower, uint repayAmount, CTokenInterface cTokenCollateral) internal nonReentrant returns (uint, uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_BORROW_INTEREST_FAILED), 0); } error = cTokenCollateral.accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but we still want to log the fact that an attempted liquidation failed return (fail(Error(error), FailureInfo.LIQUIDATE_ACCRUE_COLLATERAL_INTEREST_FAILED), 0); } // liquidateBorrowFresh emits borrow-specific logs on errors, so we don't need to return liquidateBorrowFresh(msg.sender, borrower, repayAmount, cTokenCollateral); } /** * @notice The liquidator liquidates the borrowers collateral. * The collateral seized is transferred to the liquidator. * @param borrower The borrower of this cToken to be liquidated * @param liquidator The address repaying the borrow and seizing collateral * @param cTokenCollateral The market in which to seize collateral from the borrower * @param repayAmount The amount of the underlying borrowed asset to repay * @return (uint, uint) An error code (0=success, otherwise a failure, see ErrorReporter.sol), and the actual repayment amount. */ function liquidateBorrowFresh(address liquidator, address borrower, uint repayAmount, CTokenInterface cTokenCollateral) internal returns (uint, uint) { /* Fail if liquidate not allowed */ uint allowed = comptroller.liquidateBorrowAllowed(address(this), address(cTokenCollateral), liquidator, borrower, repayAmount); if (allowed != 0) { return (failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.LIQUIDATE_COMPTROLLER_REJECTION, allowed), 0); } /* Verify market's block number equals current block number */ if (accrualBlockNumber != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_FRESHNESS_CHECK), 0); } /* Verify cTokenCollateral market's block number equals current block number */ if (cTokenCollateral.accrualBlockNumber() != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.LIQUIDATE_COLLATERAL_FRESHNESS_CHECK), 0); } /* Fail if borrower = liquidator */ if (borrower == liquidator) { return (fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_LIQUIDATOR_IS_BORROWER), 0); } /* Fail if repayAmount = 0 */ if (repayAmount == 0) { return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_ZERO), 0); } /* Fail if repayAmount = -1 */ if (repayAmount == uint(-1)) { return (fail(Error.INVALID_CLOSE_AMOUNT_REQUESTED, FailureInfo.LIQUIDATE_CLOSE_AMOUNT_IS_UINT_MAX), 0); } /* Fail if repayBorrow fails */ (uint repayBorrowError, uint actualRepayAmount) = repayBorrowFresh(liquidator, borrower, repayAmount); if (repayBorrowError != uint(Error.NO_ERROR)) { return (fail(Error(repayBorrowError), FailureInfo.LIQUIDATE_REPAY_BORROW_FRESH_FAILED), 0); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* We calculate the number of collateral tokens that will be seized */ (uint amountSeizeError, uint seizeTokens) = comptroller.liquidateCalculateSeizeTokens(address(this), address(cTokenCollateral), actualRepayAmount); require(amountSeizeError == uint(Error.NO_ERROR), "LIQUIDATE_COMPTROLLER_CALCULATE_AMOUNT_SEIZE_FAILED"); /* Revert if borrower collateral token balance < seizeTokens */ require(cTokenCollateral.balanceOf(borrower) >= seizeTokens, "LIQUIDATE_SEIZE_TOO_MUCH"); // If this is also the collateral, run seizeInternal to avoid re-entrancy, otherwise make an external call uint seizeError; if (address(cTokenCollateral) == address(this)) { seizeError = seizeInternal(address(this), liquidator, borrower, seizeTokens); } else { seizeError = cTokenCollateral.seize(liquidator, borrower, seizeTokens); } /* Revert if seize tokens fails (since we cannot be sure of side effects) */ require(seizeError == uint(Error.NO_ERROR), "token seizure failed"); /* We emit a LiquidateBorrow event */ emit LiquidateBorrow(liquidator, borrower, actualRepayAmount, address(cTokenCollateral), seizeTokens); /* We call the defense hook */ comptroller.liquidateBorrowVerify(address(this), address(cTokenCollateral), liquidator, borrower, actualRepayAmount, seizeTokens); return (uint(Error.NO_ERROR), actualRepayAmount); } /** * @notice Transfers collateral tokens (this market) to the liquidator. * @dev Will fail unless called by another cToken during the process of liquidation. * Its absolutely critical to use msg.sender as the borrowed cToken and not a parameter. * @param liquidator The account receiving seized collateral * @param borrower The account having collateral seized * @param seizeTokens The number of cTokens to seize * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function seize(address liquidator, address borrower, uint seizeTokens) external nonReentrant returns (uint) { return seizeInternal(msg.sender, liquidator, borrower, seizeTokens); } /** * @notice Transfers collateral tokens (this market) to the liquidator. * @dev Called only during an in-kind liquidation, or by liquidateBorrow during the liquidation of another CToken. * Its absolutely critical to use msg.sender as the seizer cToken and not a parameter. * @param seizerToken The contract seizing the collateral (i.e. borrowed cToken) * @param liquidator The account receiving seized collateral * @param borrower The account having collateral seized * @param seizeTokens The number of cTokens to seize * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function seizeInternal(address seizerToken, address liquidator, address borrower, uint seizeTokens) internal returns (uint) { /* Fail if seize not allowed */ uint allowed = comptroller.seizeAllowed(address(this), seizerToken, liquidator, borrower, seizeTokens); if (allowed != 0) { return failOpaque(Error.COMPTROLLER_REJECTION, FailureInfo.LIQUIDATE_SEIZE_COMPTROLLER_REJECTION, allowed); } /* Fail if borrower = liquidator */ if (borrower == liquidator) { return fail(Error.INVALID_ACCOUNT_PAIR, FailureInfo.LIQUIDATE_SEIZE_LIQUIDATOR_IS_BORROWER); } MathError mathErr; uint borrowerTokensNew; uint liquidatorTokensNew; /* * We calculate the new borrower and liquidator token balances, failing on underflow/overflow: * borrowerTokensNew = accountTokens[borrower] - seizeTokens * liquidatorTokensNew = accountTokens[liquidator] + seizeTokens */ (mathErr, borrowerTokensNew) = subUInt(accountTokens[borrower], seizeTokens); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_DECREMENT_FAILED, uint(mathErr)); } (mathErr, liquidatorTokensNew) = addUInt(accountTokens[liquidator], seizeTokens); if (mathErr != MathError.NO_ERROR) { return failOpaque(Error.MATH_ERROR, FailureInfo.LIQUIDATE_SEIZE_BALANCE_INCREMENT_FAILED, uint(mathErr)); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* We write the previously calculated values into storage */ accountTokens[borrower] = borrowerTokensNew; accountTokens[liquidator] = liquidatorTokensNew; /* Emit a Transfer event */ emit Transfer(borrower, liquidator, seizeTokens); /* We call the defense hook */ comptroller.seizeVerify(address(this), seizerToken, liquidator, borrower, seizeTokens); return uint(Error.NO_ERROR); } /*** Admin Functions ***/ /** * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer. * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer. * @param newPendingAdmin New pending admin. * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setPendingAdmin(address payable newPendingAdmin) external returns (uint) { // Check caller = admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK); } // Save current value, if any, for inclusion in log address oldPendingAdmin = pendingAdmin; // Store pendingAdmin with value newPendingAdmin pendingAdmin = newPendingAdmin; // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin) emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin); return uint(Error.NO_ERROR); } /** * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin * @dev Admin function for pending admin to accept role and update admin * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _acceptAdmin() external returns (uint) { // Check caller is pendingAdmin and pendingAdmin ≠ address(0) if (msg.sender != pendingAdmin || msg.sender == address(0)) { return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK); } // Save current values for inclusion in log address oldAdmin = admin; address oldPendingAdmin = pendingAdmin; // Store admin with value pendingAdmin admin = pendingAdmin; // Clear the pending value pendingAdmin = address(0); emit NewAdmin(oldAdmin, admin); emit NewPendingAdmin(oldPendingAdmin, pendingAdmin); return uint(Error.NO_ERROR); } /** * @notice Sets a new comptroller for the market * @dev Admin function to set a new comptroller * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setComptroller(ComptrollerInterface newComptroller) public returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_COMPTROLLER_OWNER_CHECK); } ComptrollerInterface oldComptroller = comptroller; // Ensure invoke comptroller.isComptroller() returns true require(newComptroller.isComptroller(), "marker method returned false"); // Set market's comptroller to newComptroller comptroller = newComptroller; // Emit NewComptroller(oldComptroller, newComptroller) emit NewComptroller(oldComptroller, newComptroller); return uint(Error.NO_ERROR); } /** * @notice accrues interest and sets a new reserve factor for the protocol using _setReserveFactorFresh * @dev Admin function to accrue interest and set a new reserve factor * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setReserveFactor(uint newReserveFactorMantissa) external nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reserve factor change failed. return fail(Error(error), FailureInfo.SET_RESERVE_FACTOR_ACCRUE_INTEREST_FAILED); } // _setReserveFactorFresh emits reserve-factor-specific logs on errors, so we don't need to. return _setReserveFactorFresh(newReserveFactorMantissa); } /** * @notice Sets a new reserve factor for the protocol (*requires fresh interest accrual) * @dev Admin function to set a new reserve factor * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setReserveFactorFresh(uint newReserveFactorMantissa) internal returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_RESERVE_FACTOR_ADMIN_CHECK); } // Verify market's block number equals current block number if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_RESERVE_FACTOR_FRESH_CHECK); } // Check newReserveFactor ≤ maxReserveFactor if (newReserveFactorMantissa > reserveFactorMaxMantissa) { return fail(Error.BAD_INPUT, FailureInfo.SET_RESERVE_FACTOR_BOUNDS_CHECK); } uint oldReserveFactorMantissa = reserveFactorMantissa; reserveFactorMantissa = newReserveFactorMantissa; emit NewReserveFactor(oldReserveFactorMantissa, newReserveFactorMantissa); return uint(Error.NO_ERROR); } /** * @notice Accrues interest and reduces reserves by transferring from msg.sender * @param addAmount Amount of addition to reserves * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _addReservesInternal(uint addAmount) internal nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reduce reserves failed. return fail(Error(error), FailureInfo.ADD_RESERVES_ACCRUE_INTEREST_FAILED); } // _addReservesFresh emits reserve-addition-specific logs on errors, so we don't need to. (error, ) = _addReservesFresh(addAmount); return error; } /** * @notice Add reserves by transferring from caller * @dev Requires fresh interest accrual * @param addAmount Amount of addition to reserves * @return (uint, uint) An error code (0=success, otherwise a failure (see ErrorReporter.sol for details)) and the actual amount added, net token fees */ function _addReservesFresh(uint addAmount) internal returns (uint, uint) { // totalReserves + actualAddAmount uint totalReservesNew; uint actualAddAmount; // We fail gracefully unless market's block number equals current block number if (accrualBlockNumber != getBlockNumber()) { return (fail(Error.MARKET_NOT_FRESH, FailureInfo.ADD_RESERVES_FRESH_CHECK), actualAddAmount); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) /* * We call doTransferIn for the caller and the addAmount * Note: The cToken must handle variations between ERC-20 and ETH underlying. * On success, the cToken holds an additional addAmount of cash. * doTransferIn reverts if anything goes wrong, since we can't be sure if side effects occurred. * it returns the amount actually transferred, in case of a fee. */ actualAddAmount = doTransferIn(msg.sender, addAmount); totalReservesNew = totalReserves + actualAddAmount; /* Revert on overflow */ require(totalReservesNew >= totalReserves, "add reserves unexpected overflow"); // Store reserves[n+1] = reserves[n] + actualAddAmount totalReserves = totalReservesNew; /* Emit NewReserves(admin, actualAddAmount, reserves[n+1]) */ emit ReservesAdded(msg.sender, actualAddAmount, totalReservesNew); /* Return (NO_ERROR, actualAddAmount) */ return (uint(Error.NO_ERROR), actualAddAmount); } /** * @notice Accrues interest and reduces reserves by transferring to admin * @param reduceAmount Amount of reduction to reserves * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _reduceReserves(uint reduceAmount) external nonReentrant returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted reduce reserves failed. return fail(Error(error), FailureInfo.REDUCE_RESERVES_ACCRUE_INTEREST_FAILED); } // _reduceReservesFresh emits reserve-reduction-specific logs on errors, so we don't need to. return _reduceReservesFresh(reduceAmount); } /** * @notice Reduces reserves by transferring to admin * @dev Requires fresh interest accrual * @param reduceAmount Amount of reduction to reserves * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _reduceReservesFresh(uint reduceAmount) internal returns (uint) { // totalReserves - reduceAmount uint totalReservesNew; // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.REDUCE_RESERVES_ADMIN_CHECK); } // We fail gracefully unless market's block number equals current block number if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.REDUCE_RESERVES_FRESH_CHECK); } // Fail gracefully if protocol has insufficient underlying cash if (getCashPrior() < reduceAmount) { return fail(Error.TOKEN_INSUFFICIENT_CASH, FailureInfo.REDUCE_RESERVES_CASH_NOT_AVAILABLE); } // Check reduceAmount ≤ reserves[n] (totalReserves) if (reduceAmount > totalReserves) { return fail(Error.BAD_INPUT, FailureInfo.REDUCE_RESERVES_VALIDATION); } ///////////////////////// // EFFECTS & INTERACTIONS // (No safe failures beyond this point) totalReservesNew = totalReserves - reduceAmount; // We checked reduceAmount <= totalReserves above, so this should never revert. require(totalReservesNew <= totalReserves, "reduce reserves unexpected underflow"); // Store reserves[n+1] = reserves[n] - reduceAmount totalReserves = totalReservesNew; // doTransferOut reverts if anything goes wrong, since we can't be sure if side effects occurred. doTransferOut(admin, reduceAmount); emit ReservesReduced(admin, reduceAmount, totalReservesNew); return uint(Error.NO_ERROR); } /** * @notice accrues interest and updates the interest rate model using _setInterestRateModelFresh * @dev Admin function to accrue interest and update the interest rate model * @param newInterestRateModel the new interest rate model to use * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setInterestRateModel(InterestRateModel newInterestRateModel) public returns (uint) { uint error = accrueInterest(); if (error != uint(Error.NO_ERROR)) { // accrueInterest emits logs on errors, but on top of that we want to log the fact that an attempted change of interest rate model failed return fail(Error(error), FailureInfo.SET_INTEREST_RATE_MODEL_ACCRUE_INTEREST_FAILED); } // _setInterestRateModelFresh emits interest-rate-model-update-specific logs on errors, so we don't need to. return _setInterestRateModelFresh(newInterestRateModel); } /** * @notice updates the interest rate model (*requires fresh interest accrual) * @dev Admin function to update the interest rate model * @param newInterestRateModel the new interest rate model to use * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setInterestRateModelFresh(InterestRateModel newInterestRateModel) internal returns (uint) { // Used to store old model for use in the event that is emitted on success InterestRateModel oldInterestRateModel; // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_INTEREST_RATE_MODEL_OWNER_CHECK); } // We fail gracefully unless market's block number equals current block number if (accrualBlockNumber != getBlockNumber()) { return fail(Error.MARKET_NOT_FRESH, FailureInfo.SET_INTEREST_RATE_MODEL_FRESH_CHECK); } // Track the market's current interest rate model oldInterestRateModel = interestRateModel; // Ensure invoke newInterestRateModel.isInterestRateModel() returns true require(newInterestRateModel.isInterestRateModel(), "marker method returned false"); // Set the interest rate model to newInterestRateModel interestRateModel = newInterestRateModel; // Emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel) emit NewMarketInterestRateModel(oldInterestRateModel, newInterestRateModel); return uint(Error.NO_ERROR); } /*** Safe Token ***/ /** * @notice Gets balance of this contract in terms of the underlying * @dev This excludes the value of the current message, if any * @return The quantity of underlying owned by this contract */ function getCashPrior() internal view returns (uint); /** * @dev Performs a transfer in, reverting upon failure. Returns the amount actually transferred to the protocol, in case of a fee. * This may revert due to insufficient balance or insufficient allowance. */ function doTransferIn(address from, uint amount) internal returns (uint); /** * @dev Performs a transfer out, ideally returning an explanatory error code upon failure tather than reverting. * If caller has not called checked protocol's balance, may revert due to insufficient cash held in the contract. * If caller has checked protocol's balance, and verified it is >= amount, this should not revert in normal conditions. */ function doTransferOut(address payable to, uint amount) internal; /*** Reentrancy Guard ***/ /** * @dev Prevents a contract from calling itself, directly or indirectly. */ modifier nonReentrant() { require(_notEntered, "re-entered"); _notEntered = false; _; _notEntered = true; // get a gas-refund post-Istanbul } } // File: contracts/PriceOracle.sol pragma solidity ^0.5.16; contract PriceOracle { /// @notice Indicator that this is a PriceOracle contract (for inspection) bool public constant isPriceOracle = true; /** * @notice Get the underlying price of a cToken asset * @param cToken The cToken to get the underlying price of * @return The underlying asset price mantissa (scaled by 1e18). * Zero means the price is unavailable. */ function getUnderlyingPrice(CToken cToken) external view returns (uint); } // File: contracts/ComptrollerStorage.sol pragma solidity ^0.5.16; contract UnitrollerAdminStorage { /** * @notice Administrator for this contract */ address public admin; /** * @notice Pending administrator for this contract */ address public pendingAdmin; /** * @notice Active brains of Unitroller */ address public comptrollerImplementation; /** * @notice Pending brains of Unitroller */ address public pendingComptrollerImplementation; } contract ComptrollerV1Storage is UnitrollerAdminStorage { /** * @notice Oracle which gives the price of any given asset */ PriceOracle public oracle; /** * @notice Multiplier used to calculate the maximum repayAmount when liquidating a borrow */ uint public closeFactorMantissa; /** * @notice Multiplier representing the discount on collateral that a liquidator receives */ uint public liquidationIncentiveMantissa; /** * @notice Max number of assets a single account can participate in (borrow or use as collateral) */ uint public maxAssets; /** * @notice Per-account mapping of "assets you are in", capped by maxAssets */ mapping(address => CToken[]) public accountAssets; } contract ComptrollerV2Storage is ComptrollerV1Storage { struct Market { /// @notice Whether or not this market is listed bool isListed; /** * @notice Multiplier representing the most one can borrow against their collateral in this market. * For instance, 0.9 to allow borrowing 90% of collateral value. * Must be between 0 and 1, and stored as a mantissa. */ uint collateralFactorMantissa; /// @notice Per-market mapping of "accounts in this asset" mapping(address => bool) accountMembership; /// @notice Whether or not this market receives COMP bool isComped; } /** * @notice Official mapping of cTokens -> Market metadata * @dev Used e.g. to determine if a market is supported */ mapping(address => Market) public markets; /** * @notice The Pause Guardian can pause certain actions as a safety mechanism. * Actions which allow users to remove their own assets cannot be paused. * Liquidation / seizing / transfer can only be paused globally, not by market. */ address public pauseGuardian; bool public _mintGuardianPaused; bool public _borrowGuardianPaused; bool public transferGuardianPaused; bool public seizeGuardianPaused; mapping(address => bool) public mintGuardianPaused; mapping(address => bool) public borrowGuardianPaused; } contract ComptrollerV3Storage is ComptrollerV2Storage { struct CompMarketState { /// @notice The market's last updated compBorrowIndex or compSupplyIndex uint224 index; /// @notice The block number the index was last updated at uint32 block; } /// @notice A list of all markets CToken[] public allMarkets; /// @notice The rate at which the flywheel distributes COMP, per block uint public compRate; /// @notice The portion of compRate that each market currently receives mapping(address => uint) public compSpeeds; /// @notice The COMP market supply state for each market mapping(address => CompMarketState) public compSupplyState; /// @notice The COMP market borrow state for each market mapping(address => CompMarketState) public compBorrowState; /// @notice The COMP borrow index for each market for each supplier as of the last time they accrued COMP mapping(address => mapping(address => uint)) public compSupplierIndex; /// @notice The COMP borrow index for each market for each borrower as of the last time they accrued COMP mapping(address => mapping(address => uint)) public compBorrowerIndex; /// @notice The COMP accrued but not yet transferred to each user mapping(address => uint) public compAccrued; } // File: contracts/Unitroller.sol pragma solidity ^0.5.16; /** * @title ComptrollerCore * @dev Storage for the comptroller is at this address, while execution is delegated to the `comptrollerImplementation`. * CTokens should reference this contract as their comptroller. */ contract Unitroller is UnitrollerAdminStorage, ComptrollerErrorReporter { /** * @notice Emitted when pendingComptrollerImplementation is changed */ event NewPendingImplementation(address oldPendingImplementation, address newPendingImplementation); /** * @notice Emitted when pendingComptrollerImplementation is accepted, which means comptroller implementation is updated */ event NewImplementation(address oldImplementation, address newImplementation); /** * @notice Emitted when pendingAdmin is changed */ event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin); /** * @notice Emitted when pendingAdmin is accepted, which means admin is updated */ event NewAdmin(address oldAdmin, address newAdmin); constructor() public { // Set admin to caller admin = msg.sender; } /*** Admin Functions ***/ function _setPendingImplementation(address newPendingImplementation) public returns (uint) { if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_IMPLEMENTATION_OWNER_CHECK); } address oldPendingImplementation = pendingComptrollerImplementation; pendingComptrollerImplementation = newPendingImplementation; emit NewPendingImplementation(oldPendingImplementation, pendingComptrollerImplementation); return uint(Error.NO_ERROR); } /** * @notice Accepts new implementation of comptroller. msg.sender must be pendingImplementation * @dev Admin function for new implementation to accept it's role as implementation * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _acceptImplementation() public returns (uint) { // Check caller is pendingImplementation and pendingImplementation ≠ address(0) if (msg.sender != pendingComptrollerImplementation || pendingComptrollerImplementation == address(0)) { return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_PENDING_IMPLEMENTATION_ADDRESS_CHECK); } // Save current values for inclusion in log address oldImplementation = comptrollerImplementation; address oldPendingImplementation = pendingComptrollerImplementation; comptrollerImplementation = pendingComptrollerImplementation; pendingComptrollerImplementation = address(0); emit NewImplementation(oldImplementation, comptrollerImplementation); emit NewPendingImplementation(oldPendingImplementation, pendingComptrollerImplementation); return uint(Error.NO_ERROR); } /** * @notice Begins transfer of admin rights. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer. * @dev Admin function to begin change of admin. The newPendingAdmin must call `_acceptAdmin` to finalize the transfer. * @param newPendingAdmin New pending admin. * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setPendingAdmin(address newPendingAdmin) public returns (uint) { // Check caller = admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PENDING_ADMIN_OWNER_CHECK); } // Save current value, if any, for inclusion in log address oldPendingAdmin = pendingAdmin; // Store pendingAdmin with value newPendingAdmin pendingAdmin = newPendingAdmin; // Emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin) emit NewPendingAdmin(oldPendingAdmin, newPendingAdmin); return uint(Error.NO_ERROR); } /** * @notice Accepts transfer of admin rights. msg.sender must be pendingAdmin * @dev Admin function for pending admin to accept role and update admin * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _acceptAdmin() public returns (uint) { // Check caller is pendingAdmin and pendingAdmin ≠ address(0) if (msg.sender != pendingAdmin || msg.sender == address(0)) { return fail(Error.UNAUTHORIZED, FailureInfo.ACCEPT_ADMIN_PENDING_ADMIN_CHECK); } // Save current values for inclusion in log address oldAdmin = admin; address oldPendingAdmin = pendingAdmin; // Store admin with value pendingAdmin admin = pendingAdmin; // Clear the pending value pendingAdmin = address(0); emit NewAdmin(oldAdmin, admin); emit NewPendingAdmin(oldPendingAdmin, pendingAdmin); return uint(Error.NO_ERROR); } /** * @dev Delegates execution to an implementation contract. * It returns to the external caller whatever the implementation returns * or forwards reverts. */ function () payable external { // delegate all other functions to current implementation (bool success, ) = comptrollerImplementation.delegatecall(msg.data); assembly { let free_mem_ptr := mload(0x40) returndatacopy(free_mem_ptr, 0, returndatasize) switch success case 0 { revert(free_mem_ptr, returndatasize) } default { return(free_mem_ptr, returndatasize) } } } } // File: contracts/Governance/Comp.sol pragma solidity ^0.5.16; contract Comp { /// @notice EIP-20 token name for this token string public constant name = "OPEN Governance Token"; /// @notice EIP-20 token symbol for this token string public constant symbol = "OPEN"; /// @notice EIP-20 token decimals for this token uint8 public constant decimals = 18; /// @notice Total number of tokens in circulation uint public constant totalSupply = 100000000e18; // 100 million OPEN /// @notice Allowance amounts on behalf of others mapping (address => mapping (address => uint96)) internal allowances; /// @notice Official record of token balances for each account mapping (address => uint96) internal balances; /// @notice A record of each accounts delegate mapping (address => address) public delegates; /// @notice A checkpoint for marking number of votes from a given block struct Checkpoint { uint32 fromBlock; uint96 votes; } /// @notice A record of votes checkpoints for each account, by index mapping (address => mapping (uint32 => Checkpoint)) public checkpoints; /// @notice The number of checkpoints for each account mapping (address => uint32) public numCheckpoints; /// @notice The EIP-712 typehash for the contract's domain bytes32 public constant DOMAIN_TYPEHASH = keccak256("EIP712Domain(string name,uint256 chainId,address verifyingContract)"); /// @notice The EIP-712 typehash for the delegation struct used by the contract bytes32 public constant DELEGATION_TYPEHASH = keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)"); /// @notice A record of states for signing / validating signatures mapping (address => uint) public nonces; /// @notice An event thats emitted when an account changes its delegate event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate); /// @notice An event thats emitted when a delegate account's vote balance changes event DelegateVotesChanged(address indexed delegate, uint previousBalance, uint newBalance); /// @notice The standard EIP-20 transfer event event Transfer(address indexed from, address indexed to, uint256 amount); /// @notice The standard EIP-20 approval event event Approval(address indexed owner, address indexed spender, uint256 amount); /** * @notice Construct a new Comp token * @param account The initial account to grant all the tokens */ constructor(address account) public { balances[account] = uint96(totalSupply); emit Transfer(address(0), account, totalSupply); } /** * @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 rawAmount The number of tokens that are approved (2^256-1 means infinite) * @return Whether or not the approval succeeded */ function approve(address spender, uint rawAmount) external returns (bool) { uint96 amount; if (rawAmount == uint(-1)) { amount = uint96(-1); } else { amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits"); } 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 rawAmount The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transfer(address dst, uint rawAmount) external returns (bool) { uint96 amount = safe96(rawAmount, "Comp::transfer: amount exceeds 96 bits"); _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 rawAmount The number of tokens to transfer * @return Whether or not the transfer succeeded */ function transferFrom(address src, address dst, uint rawAmount) external returns (bool) { address spender = msg.sender; uint96 spenderAllowance = allowances[src][spender]; uint96 amount = safe96(rawAmount, "Comp::approve: amount exceeds 96 bits"); if (spender != src && spenderAllowance != uint96(-1)) { uint96 newAllowance = sub96(spenderAllowance, amount, "Comp::transferFrom: transfer amount exceeds spender allowance"); allowances[src][spender] = newAllowance; emit Approval(src, spender, newAllowance); } _transferTokens(src, dst, amount); return true; } /** * @notice Delegate votes from `msg.sender` to `delegatee` * @param delegatee The address to delegate votes to */ function delegate(address delegatee) public { return _delegate(msg.sender, delegatee); } /** * @notice Delegates votes from signatory to `delegatee` * @param delegatee The address to delegate votes to * @param nonce The contract state required to match the signature * @param expiry The time at which to expire the signature * @param v The recovery byte of the signature * @param r Half of the ECDSA signature pair * @param s Half of the ECDSA signature pair */ function delegateBySig(address delegatee, uint nonce, uint expiry, uint8 v, bytes32 r, bytes32 s) public { bytes32 domainSeparator = keccak256(abi.encode(DOMAIN_TYPEHASH, keccak256(bytes(name)), getChainId(), address(this))); bytes32 structHash = keccak256(abi.encode(DELEGATION_TYPEHASH, delegatee, nonce, expiry)); bytes32 digest = keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash)); address signatory = ecrecover(digest, v, r, s); require(signatory != address(0), "Comp::delegateBySig: invalid signature"); require(nonce == nonces[signatory]++, "Comp::delegateBySig: invalid nonce"); require(now <= expiry, "Comp::delegateBySig: signature expired"); return _delegate(signatory, delegatee); } /** * @notice Gets the current votes balance for `account` * @param account The address to get votes balance * @return The number of current votes for `account` */ function getCurrentVotes(address account) external view returns (uint96) { uint32 nCheckpoints = numCheckpoints[account]; return nCheckpoints > 0 ? checkpoints[account][nCheckpoints - 1].votes : 0; } /** * @notice Determine the prior number of votes for an account as of a block number * @dev Block number must be a finalized block or else this function will revert to prevent misinformation. * @param account The address of the account to check * @param blockNumber The block number to get the vote balance at * @return The number of votes the account had as of the given block */ function getPriorVotes(address account, uint blockNumber) public view returns (uint96) { require(blockNumber < block.number, "Comp::getPriorVotes: not yet determined"); uint32 nCheckpoints = numCheckpoints[account]; if (nCheckpoints == 0) { return 0; } // First check most recent balance if (checkpoints[account][nCheckpoints - 1].fromBlock <= blockNumber) { return checkpoints[account][nCheckpoints - 1].votes; } // Next check implicit zero balance if (checkpoints[account][0].fromBlock > blockNumber) { return 0; } uint32 lower = 0; uint32 upper = nCheckpoints - 1; while (upper > lower) { uint32 center = upper - (upper - lower) / 2; // ceil, avoiding overflow Checkpoint memory cp = checkpoints[account][center]; if (cp.fromBlock == blockNumber) { return cp.votes; } else if (cp.fromBlock < blockNumber) { lower = center; } else { upper = center - 1; } } return checkpoints[account][lower].votes; } function _delegate(address delegator, address delegatee) internal { address currentDelegate = delegates[delegator]; uint96 delegatorBalance = balances[delegator]; delegates[delegator] = delegatee; emit DelegateChanged(delegator, currentDelegate, delegatee); _moveDelegates(currentDelegate, delegatee, delegatorBalance); } function _transferTokens(address src, address dst, uint96 amount) internal { require(src != address(0), "Comp::_transferTokens: cannot transfer from the zero address"); require(dst != address(0), "Comp::_transferTokens: cannot transfer to the zero address"); balances[src] = sub96(balances[src], amount, "Comp::_transferTokens: transfer amount exceeds balance"); balances[dst] = add96(balances[dst], amount, "Comp::_transferTokens: transfer amount overflows"); emit Transfer(src, dst, amount); _moveDelegates(delegates[src], delegates[dst], amount); } function _moveDelegates(address srcRep, address dstRep, uint96 amount) internal { if (srcRep != dstRep && amount > 0) { if (srcRep != address(0)) { uint32 srcRepNum = numCheckpoints[srcRep]; uint96 srcRepOld = srcRepNum > 0 ? checkpoints[srcRep][srcRepNum - 1].votes : 0; uint96 srcRepNew = sub96(srcRepOld, amount, "Comp::_moveVotes: vote amount underflows"); _writeCheckpoint(srcRep, srcRepNum, srcRepOld, srcRepNew); } if (dstRep != address(0)) { uint32 dstRepNum = numCheckpoints[dstRep]; uint96 dstRepOld = dstRepNum > 0 ? checkpoints[dstRep][dstRepNum - 1].votes : 0; uint96 dstRepNew = add96(dstRepOld, amount, "Comp::_moveVotes: vote amount overflows"); _writeCheckpoint(dstRep, dstRepNum, dstRepOld, dstRepNew); } } } function _writeCheckpoint(address delegatee, uint32 nCheckpoints, uint96 oldVotes, uint96 newVotes) internal { uint32 blockNumber = safe32(block.number, "Comp::_writeCheckpoint: block number exceeds 32 bits"); if (nCheckpoints > 0 && checkpoints[delegatee][nCheckpoints - 1].fromBlock == blockNumber) { checkpoints[delegatee][nCheckpoints - 1].votes = newVotes; } else { checkpoints[delegatee][nCheckpoints] = Checkpoint(blockNumber, newVotes); numCheckpoints[delegatee] = nCheckpoints + 1; } emit DelegateVotesChanged(delegatee, oldVotes, newVotes); } function safe32(uint n, string memory errorMessage) internal pure returns (uint32) { require(n < 2**32, errorMessage); return uint32(n); } function safe96(uint n, string memory errorMessage) internal pure returns (uint96) { require(n < 2**96, errorMessage); return uint96(n); } function add96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) { uint96 c = a + b; require(c >= a, errorMessage); return c; } function sub96(uint96 a, uint96 b, string memory errorMessage) internal pure returns (uint96) { require(b <= a, errorMessage); return a - b; } function getChainId() internal pure returns (uint) { uint256 chainId; assembly { chainId := chainid() } return chainId; } } // File: contracts/Comptroller.sol pragma solidity ^0.5.16; /** * @title Compound's Comptroller Contract * @author Compound */ contract Comptroller is ComptrollerV3Storage, ComptrollerInterface, ComptrollerErrorReporter, Exponential { /// @notice Emitted when an admin supports a market event MarketListed(CToken cToken); /// @notice Emitted when an account enters a market event MarketEntered(CToken cToken, address account); /// @notice Emitted when an account exits a market event MarketExited(CToken cToken, address account); /// @notice Emitted when close factor is changed by admin event NewCloseFactor(uint oldCloseFactorMantissa, uint newCloseFactorMantissa); /// @notice Emitted when a collateral factor is changed by admin event NewCollateralFactor(CToken cToken, uint oldCollateralFactorMantissa, uint newCollateralFactorMantissa); /// @notice Emitted when liquidation incentive is changed by admin event NewLiquidationIncentive(uint oldLiquidationIncentiveMantissa, uint newLiquidationIncentiveMantissa); /// @notice Emitted when maxAssets is changed by admin event NewMaxAssets(uint oldMaxAssets, uint newMaxAssets); /// @notice Emitted when price oracle is changed event NewPriceOracle(PriceOracle oldPriceOracle, PriceOracle newPriceOracle); /// @notice Emitted when pause guardian is changed event NewPauseGuardian(address oldPauseGuardian, address newPauseGuardian); /// @notice Emitted when an action is paused globally event ActionPaused(string action, bool pauseState); /// @notice Emitted when an action is paused on a market event ActionPaused(CToken cToken, string action, bool pauseState); /// @notice Emitted when market comped status is changed event MarketComped(CToken cToken, bool isComped); /// @notice Emitted when COMP rate is changed event NewCompRate(uint oldCompRate, uint newCompRate); /// @notice Emitted when a new COMP speed is calculated for a market event CompSpeedUpdated(CToken indexed cToken, uint newSpeed); /// @notice Emitted when COMP is distributed to a supplier event DistributedSupplierComp(CToken indexed cToken, address indexed supplier, uint compDelta, uint compSupplyIndex); /// @notice Emitted when COMP is distributed to a borrower event DistributedBorrowerComp(CToken indexed cToken, address indexed borrower, uint compDelta, uint compBorrowIndex); /// @notice The threshold above which the flywheel transfers COMP, in wei uint public constant compClaimThreshold = 0.001e18; /// @notice The initial COMP index for a market uint224 public constant compInitialIndex = 1e36; // closeFactorMantissa must be strictly greater than this value uint internal constant closeFactorMinMantissa = 0.05e18; // 0.05 // closeFactorMantissa must not exceed this value uint internal constant closeFactorMaxMantissa = 0.9e18; // 0.9 // No collateralFactorMantissa may exceed this value uint internal constant collateralFactorMaxMantissa = 0.9e18; // 0.9 // liquidationIncentiveMantissa must be no less than this value uint internal constant liquidationIncentiveMinMantissa = 1.0e18; // 1.0 // liquidationIncentiveMantissa must be no greater than this value uint internal constant liquidationIncentiveMaxMantissa = 1.5e18; // 1.5 constructor() public { admin = msg.sender; } /*** Assets You Are In ***/ /** * @notice Returns the assets an account has entered * @param account The address of the account to pull assets for * @return A dynamic list with the assets the account has entered */ function getAssetsIn(address account) external view returns (CToken[] memory) { CToken[] memory assetsIn = accountAssets[account]; return assetsIn; } /** * @notice Returns whether the given account is entered in the given asset * @param account The address of the account to check * @param cToken The cToken to check * @return True if the account is in the asset, otherwise false. */ function checkMembership(address account, CToken cToken) external view returns (bool) { return markets[address(cToken)].accountMembership[account]; } /** * @notice Add assets to be included in account liquidity calculation * @param cTokens The list of addresses of the cToken markets to be enabled * @return Success indicator for whether each corresponding market was entered */ function enterMarkets(address[] memory cTokens) public returns (uint[] memory) { uint len = cTokens.length; uint[] memory results = new uint[](len); for (uint i = 0; i < len; i++) { CToken cToken = CToken(cTokens[i]); results[i] = uint(addToMarketInternal(cToken, msg.sender)); } return results; } /** * @notice Add the market to the borrower's "assets in" for liquidity calculations * @param cToken The market to enter * @param borrower The address of the account to modify * @return Success indicator for whether the market was entered */ function addToMarketInternal(CToken cToken, address borrower) internal returns (Error) { Market storage marketToJoin = markets[address(cToken)]; if (!marketToJoin.isListed) { // market is not listed, cannot join return Error.MARKET_NOT_LISTED; } if (marketToJoin.accountMembership[borrower] == true) { // already joined return Error.NO_ERROR; } if (accountAssets[borrower].length >= maxAssets) { // no space, cannot join return Error.TOO_MANY_ASSETS; } // survived the gauntlet, add to list // NOTE: we store these somewhat redundantly as a significant optimization // this avoids having to iterate through the list for the most common use cases // that is, only when we need to perform liquidity checks // and not whenever we want to check if an account is in a particular market marketToJoin.accountMembership[borrower] = true; accountAssets[borrower].push(cToken); emit MarketEntered(cToken, borrower); return Error.NO_ERROR; } /** * @notice Removes asset from sender's account liquidity calculation * @dev Sender must not have an outstanding borrow balance in the asset, * or be providing necessary collateral for an outstanding borrow. * @param cTokenAddress The address of the asset to be removed * @return Whether or not the account successfully exited the market */ function exitMarket(address cTokenAddress) external returns (uint) { CToken cToken = CToken(cTokenAddress); /* Get sender tokensHeld and amountOwed underlying from the cToken */ (uint oErr, uint tokensHeld, uint amountOwed, ) = cToken.getAccountSnapshot(msg.sender); require(oErr == 0, "exitMarket: getAccountSnapshot failed"); // semi-opaque error code /* Fail if the sender has a borrow balance */ if (amountOwed != 0) { return fail(Error.NONZERO_BORROW_BALANCE, FailureInfo.EXIT_MARKET_BALANCE_OWED); } /* Fail if the sender is not permitted to redeem all of their tokens */ uint allowed = redeemAllowedInternal(cTokenAddress, msg.sender, tokensHeld); if (allowed != 0) { return failOpaque(Error.REJECTION, FailureInfo.EXIT_MARKET_REJECTION, allowed); } Market storage marketToExit = markets[address(cToken)]; /* Return true if the sender is not already ‘in’ the market */ if (!marketToExit.accountMembership[msg.sender]) { return uint(Error.NO_ERROR); } /* Set cToken account membership to false */ delete marketToExit.accountMembership[msg.sender]; /* Delete cToken from the account’s list of assets */ // load into memory for faster iteration CToken[] memory userAssetList = accountAssets[msg.sender]; uint len = userAssetList.length; uint assetIndex = len; for (uint i = 0; i < len; i++) { if (userAssetList[i] == cToken) { assetIndex = i; break; } } // We *must* have found the asset in the list or our redundant data structure is broken assert(assetIndex < len); // copy last item in list to location of item to be removed, reduce length by 1 CToken[] storage storedList = accountAssets[msg.sender]; storedList[assetIndex] = storedList[storedList.length - 1]; storedList.length--; emit MarketExited(cToken, msg.sender); return uint(Error.NO_ERROR); } /*** Policy Hooks ***/ /** * @notice Checks if the account should be allowed to mint tokens in the given market * @param cToken The market to verify the mint against * @param minter The account which would get the minted tokens * @param mintAmount The amount of underlying being supplied to the market in exchange for tokens * @return 0 if the mint is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function mintAllowed(address cToken, address minter, uint mintAmount) external returns (uint) { // Pausing is a very serious situation - we revert to sound the alarms require(!mintGuardianPaused[cToken], "mint is paused"); // Shh - currently unused minter; mintAmount; if (!markets[cToken].isListed) { return uint(Error.MARKET_NOT_LISTED); } // Keep the flywheel moving updateCompSupplyIndex(cToken); distributeSupplierComp(cToken, minter, false); return uint(Error.NO_ERROR); } /** * @notice Validates mint and reverts on rejection. May emit logs. * @param cToken Asset being minted * @param minter The address minting the tokens * @param actualMintAmount The amount of the underlying asset being minted * @param mintTokens The number of tokens being minted */ function mintVerify(address cToken, address minter, uint actualMintAmount, uint mintTokens) external { // Shh - currently unused cToken; minter; actualMintAmount; mintTokens; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the account should be allowed to redeem tokens in the given market * @param cToken The market to verify the redeem against * @param redeemer The account which would redeem the tokens * @param redeemTokens The number of cTokens to exchange for the underlying asset in the market * @return 0 if the redeem is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function redeemAllowed(address cToken, address redeemer, uint redeemTokens) external returns (uint) { uint allowed = redeemAllowedInternal(cToken, redeemer, redeemTokens); if (allowed != uint(Error.NO_ERROR)) { return allowed; } // Keep the flywheel moving updateCompSupplyIndex(cToken); distributeSupplierComp(cToken, redeemer, false); return uint(Error.NO_ERROR); } function redeemAllowedInternal(address cToken, address redeemer, uint redeemTokens) internal view returns (uint) { if (!markets[cToken].isListed) { return uint(Error.MARKET_NOT_LISTED); } /* If the redeemer is not 'in' the market, then we can bypass the liquidity check */ if (!markets[cToken].accountMembership[redeemer]) { return uint(Error.NO_ERROR); } /* Otherwise, perform a hypothetical liquidity check to guard against shortfall */ (Error err, , uint shortfall) = getHypotheticalAccountLiquidityInternal(redeemer, CToken(cToken), redeemTokens, 0); if (err != Error.NO_ERROR) { return uint(err); } if (shortfall > 0) { return uint(Error.INSUFFICIENT_LIQUIDITY); } return uint(Error.NO_ERROR); } /** * @notice Validates redeem and reverts on rejection. May emit logs. * @param cToken Asset being redeemed * @param redeemer The address redeeming the tokens * @param redeemAmount The amount of the underlying asset being redeemed * @param redeemTokens The number of tokens being redeemed */ function redeemVerify(address cToken, address redeemer, uint redeemAmount, uint redeemTokens) external { // Shh - currently unused cToken; redeemer; // Require tokens is zero or amount is also zero if (redeemTokens == 0 && redeemAmount > 0) { revert("redeemTokens zero"); } } /** * @notice Checks if the account should be allowed to borrow the underlying asset of the given market * @param cToken The market to verify the borrow against * @param borrower The account which would borrow the asset * @param borrowAmount The amount of underlying the account would borrow * @return 0 if the borrow is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function borrowAllowed(address cToken, address borrower, uint borrowAmount) external returns (uint) { // Pausing is a very serious situation - we revert to sound the alarms require(!borrowGuardianPaused[cToken], "borrow is paused"); if (!markets[cToken].isListed) { return uint(Error.MARKET_NOT_LISTED); } if (!markets[cToken].accountMembership[borrower]) { // only cTokens may call borrowAllowed if borrower not in market require(msg.sender == cToken, "sender must be cToken"); // attempt to add borrower to the market Error err = addToMarketInternal(CToken(msg.sender), borrower); if (err != Error.NO_ERROR) { return uint(err); } // it should be impossible to break the important invariant assert(markets[cToken].accountMembership[borrower]); } if (oracle.getUnderlyingPrice(CToken(cToken)) == 0) { return uint(Error.PRICE_ERROR); } (Error err, , uint shortfall) = getHypotheticalAccountLiquidityInternal(borrower, CToken(cToken), 0, borrowAmount); if (err != Error.NO_ERROR) { return uint(err); } if (shortfall > 0) { return uint(Error.INSUFFICIENT_LIQUIDITY); } // Keep the flywheel moving Exp memory borrowIndex = Exp({mantissa: CToken(cToken).borrowIndex()}); updateCompBorrowIndex(cToken, borrowIndex); distributeBorrowerComp(cToken, borrower, borrowIndex, false); return uint(Error.NO_ERROR); } /** * @notice Validates borrow and reverts on rejection. May emit logs. * @param cToken Asset whose underlying is being borrowed * @param borrower The address borrowing the underlying * @param borrowAmount The amount of the underlying asset requested to borrow */ function borrowVerify(address cToken, address borrower, uint borrowAmount) external { // Shh - currently unused cToken; borrower; borrowAmount; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the account should be allowed to repay a borrow in the given market * @param cToken The market to verify the repay against * @param payer The account which would repay the asset * @param borrower The account which would borrowed the asset * @param repayAmount The amount of the underlying asset the account would repay * @return 0 if the repay is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function repayBorrowAllowed( address cToken, address payer, address borrower, uint repayAmount) external returns (uint) { // Shh - currently unused payer; borrower; repayAmount; if (!markets[cToken].isListed) { return uint(Error.MARKET_NOT_LISTED); } // Keep the flywheel moving Exp memory borrowIndex = Exp({mantissa: CToken(cToken).borrowIndex()}); updateCompBorrowIndex(cToken, borrowIndex); distributeBorrowerComp(cToken, borrower, borrowIndex, false); return uint(Error.NO_ERROR); } /** * @notice Validates repayBorrow and reverts on rejection. May emit logs. * @param cToken Asset being repaid * @param payer The address repaying the borrow * @param borrower The address of the borrower * @param actualRepayAmount The amount of underlying being repaid */ function repayBorrowVerify( address cToken, address payer, address borrower, uint actualRepayAmount, uint borrowerIndex) external { // Shh - currently unused cToken; payer; borrower; actualRepayAmount; borrowerIndex; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the liquidation should be allowed to occur * @param cTokenBorrowed Asset which was borrowed by the borrower * @param cTokenCollateral Asset which was used as collateral and will be seized * @param liquidator The address repaying the borrow and seizing the collateral * @param borrower The address of the borrower * @param repayAmount The amount of underlying being repaid */ function liquidateBorrowAllowed( address cTokenBorrowed, address cTokenCollateral, address liquidator, address borrower, uint repayAmount) external returns (uint) { // Shh - currently unused liquidator; if (!markets[cTokenBorrowed].isListed || !markets[cTokenCollateral].isListed) { return uint(Error.MARKET_NOT_LISTED); } /* The borrower must have shortfall in order to be liquidatable */ (Error err, , uint shortfall) = getAccountLiquidityInternal(borrower); if (err != Error.NO_ERROR) { return uint(err); } if (shortfall == 0) { return uint(Error.INSUFFICIENT_SHORTFALL); } /* The liquidator may not repay more than what is allowed by the closeFactor */ uint borrowBalance = CToken(cTokenBorrowed).borrowBalanceStored(borrower); (MathError mathErr, uint maxClose) = mulScalarTruncate(Exp({mantissa: closeFactorMantissa}), borrowBalance); if (mathErr != MathError.NO_ERROR) { return uint(Error.MATH_ERROR); } if (repayAmount > maxClose) { return uint(Error.TOO_MUCH_REPAY); } return uint(Error.NO_ERROR); } /** * @notice Validates liquidateBorrow and reverts on rejection. May emit logs. * @param cTokenBorrowed Asset which was borrowed by the borrower * @param cTokenCollateral Asset which was used as collateral and will be seized * @param liquidator The address repaying the borrow and seizing the collateral * @param borrower The address of the borrower * @param actualRepayAmount The amount of underlying being repaid */ function liquidateBorrowVerify( address cTokenBorrowed, address cTokenCollateral, address liquidator, address borrower, uint actualRepayAmount, uint seizeTokens) external { // Shh - currently unused cTokenBorrowed; cTokenCollateral; liquidator; borrower; actualRepayAmount; seizeTokens; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the seizing of assets should be allowed to occur * @param cTokenCollateral Asset which was used as collateral and will be seized * @param cTokenBorrowed Asset which was borrowed by the borrower * @param liquidator The address repaying the borrow and seizing the collateral * @param borrower The address of the borrower * @param seizeTokens The number of collateral tokens to seize */ function seizeAllowed( address cTokenCollateral, address cTokenBorrowed, address liquidator, address borrower, uint seizeTokens) external returns (uint) { // Pausing is a very serious situation - we revert to sound the alarms require(!seizeGuardianPaused, "seize is paused"); // Shh - currently unused seizeTokens; if (!markets[cTokenCollateral].isListed || !markets[cTokenBorrowed].isListed) { return uint(Error.MARKET_NOT_LISTED); } if (CToken(cTokenCollateral).comptroller() != CToken(cTokenBorrowed).comptroller()) { return uint(Error.COMPTROLLER_MISMATCH); } // Keep the flywheel moving updateCompSupplyIndex(cTokenCollateral); distributeSupplierComp(cTokenCollateral, borrower, false); distributeSupplierComp(cTokenCollateral, liquidator, false); return uint(Error.NO_ERROR); } /** * @notice Validates seize and reverts on rejection. May emit logs. * @param cTokenCollateral Asset which was used as collateral and will be seized * @param cTokenBorrowed Asset which was borrowed by the borrower * @param liquidator The address repaying the borrow and seizing the collateral * @param borrower The address of the borrower * @param seizeTokens The number of collateral tokens to seize */ function seizeVerify( address cTokenCollateral, address cTokenBorrowed, address liquidator, address borrower, uint seizeTokens) external { // Shh - currently unused cTokenCollateral; cTokenBorrowed; liquidator; borrower; seizeTokens; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /** * @notice Checks if the account should be allowed to transfer tokens in the given market * @param cToken The market to verify the transfer against * @param src The account which sources the tokens * @param dst The account which receives the tokens * @param transferTokens The number of cTokens to transfer * @return 0 if the transfer is allowed, otherwise a semi-opaque error code (See ErrorReporter.sol) */ function transferAllowed(address cToken, address src, address dst, uint transferTokens) external returns (uint) { // Pausing is a very serious situation - we revert to sound the alarms require(!transferGuardianPaused, "transfer is paused"); // Currently the only consideration is whether or not // the src is allowed to redeem this many tokens uint allowed = redeemAllowedInternal(cToken, src, transferTokens); if (allowed != uint(Error.NO_ERROR)) { return allowed; } // Keep the flywheel moving updateCompSupplyIndex(cToken); distributeSupplierComp(cToken, src, false); distributeSupplierComp(cToken, dst, false); return uint(Error.NO_ERROR); } /** * @notice Validates transfer and reverts on rejection. May emit logs. * @param cToken Asset being transferred * @param src The account which sources the tokens * @param dst The account which receives the tokens * @param transferTokens The number of cTokens to transfer */ function transferVerify(address cToken, address src, address dst, uint transferTokens) external { // Shh - currently unused cToken; src; dst; transferTokens; // Shh - we don't ever want this hook to be marked pure if (false) { maxAssets = maxAssets; } } /*** Liquidity/Liquidation Calculations ***/ /** * @dev Local vars for avoiding stack-depth limits in calculating account liquidity. * Note that `cTokenBalance` is the number of cTokens the account owns in the market, * whereas `borrowBalance` is the amount of underlying that the account has borrowed. */ struct AccountLiquidityLocalVars { uint sumCollateral; uint sumBorrowPlusEffects; uint cTokenBalance; uint borrowBalance; uint exchangeRateMantissa; uint oraclePriceMantissa; Exp collateralFactor; Exp exchangeRate; Exp oraclePrice; Exp tokensToDenom; } /** * @notice Determine the current account liquidity wrt collateral requirements * @return (possible error code (semi-opaque), account liquidity in excess of collateral requirements, * account shortfall below collateral requirements) */ function getAccountLiquidity(address account) public view returns (uint, uint, uint) { (Error err, uint liquidity, uint shortfall) = getHypotheticalAccountLiquidityInternal(account, CToken(0), 0, 0); return (uint(err), liquidity, shortfall); } /** * @notice Determine the current account liquidity wrt collateral requirements * @return (possible error code, account liquidity in excess of collateral requirements, * account shortfall below collateral requirements) */ function getAccountLiquidityInternal(address account) internal view returns (Error, uint, uint) { return getHypotheticalAccountLiquidityInternal(account, CToken(0), 0, 0); } /** * @notice Determine what the account liquidity would be if the given amounts were redeemed/borrowed * @param cTokenModify The market to hypothetically redeem/borrow in * @param account The account to determine liquidity for * @param redeemTokens The number of tokens to hypothetically redeem * @param borrowAmount The amount of underlying to hypothetically borrow * @return (possible error code (semi-opaque), hypothetical account liquidity in excess of collateral requirements, * hypothetical account shortfall below collateral requirements) */ function getHypotheticalAccountLiquidity( address account, address cTokenModify, uint redeemTokens, uint borrowAmount) public view returns (uint, uint, uint) { (Error err, uint liquidity, uint shortfall) = getHypotheticalAccountLiquidityInternal(account, CToken(cTokenModify), redeemTokens, borrowAmount); return (uint(err), liquidity, shortfall); } /** * @notice Determine what the account liquidity would be if the given amounts were redeemed/borrowed * @param cTokenModify The market to hypothetically redeem/borrow in * @param account The account to determine liquidity for * @param redeemTokens The number of tokens to hypothetically redeem * @param borrowAmount The amount of underlying to hypothetically borrow * @dev Note that we calculate the exchangeRateStored for each collateral cToken using stored data, * without calculating accumulated interest. * @return (possible error code, hypothetical account liquidity in excess of collateral requirements, * hypothetical account shortfall below collateral requirements) */ function getHypotheticalAccountLiquidityInternal( address account, CToken cTokenModify, uint redeemTokens, uint borrowAmount) internal view returns (Error, uint, uint) { AccountLiquidityLocalVars memory vars; // Holds all our calculation results uint oErr; MathError mErr; // For each asset the account is in CToken[] memory assets = accountAssets[account]; for (uint i = 0; i < assets.length; i++) { CToken asset = assets[i]; // Read the balances and exchange rate from the cToken (oErr, vars.cTokenBalance, vars.borrowBalance, vars.exchangeRateMantissa) = asset.getAccountSnapshot(account); if (oErr != 0) { // semi-opaque error code, we assume NO_ERROR == 0 is invariant between upgrades return (Error.SNAPSHOT_ERROR, 0, 0); } vars.collateralFactor = Exp({mantissa: markets[address(asset)].collateralFactorMantissa}); vars.exchangeRate = Exp({mantissa: vars.exchangeRateMantissa}); // Get the normalized price of the asset vars.oraclePriceMantissa = oracle.getUnderlyingPrice(asset); if (vars.oraclePriceMantissa == 0) { return (Error.PRICE_ERROR, 0, 0); } vars.oraclePrice = Exp({mantissa: vars.oraclePriceMantissa}); // Pre-compute a conversion factor from tokens -> ether (normalized price value) (mErr, vars.tokensToDenom) = mulExp3(vars.collateralFactor, vars.exchangeRate, vars.oraclePrice); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } // sumCollateral += tokensToDenom * cTokenBalance (mErr, vars.sumCollateral) = mulScalarTruncateAddUInt(vars.tokensToDenom, vars.cTokenBalance, vars.sumCollateral); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } // sumBorrowPlusEffects += oraclePrice * borrowBalance (mErr, vars.sumBorrowPlusEffects) = mulScalarTruncateAddUInt(vars.oraclePrice, vars.borrowBalance, vars.sumBorrowPlusEffects); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } // Calculate effects of interacting with cTokenModify if (asset == cTokenModify) { // redeem effect // sumBorrowPlusEffects += tokensToDenom * redeemTokens (mErr, vars.sumBorrowPlusEffects) = mulScalarTruncateAddUInt(vars.tokensToDenom, redeemTokens, vars.sumBorrowPlusEffects); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } // borrow effect // sumBorrowPlusEffects += oraclePrice * borrowAmount (mErr, vars.sumBorrowPlusEffects) = mulScalarTruncateAddUInt(vars.oraclePrice, borrowAmount, vars.sumBorrowPlusEffects); if (mErr != MathError.NO_ERROR) { return (Error.MATH_ERROR, 0, 0); } } } // These are safe, as the underflow condition is checked first if (vars.sumCollateral > vars.sumBorrowPlusEffects) { return (Error.NO_ERROR, vars.sumCollateral - vars.sumBorrowPlusEffects, 0); } else { return (Error.NO_ERROR, 0, vars.sumBorrowPlusEffects - vars.sumCollateral); } } /** * @notice Calculate number of tokens of collateral asset to seize given an underlying amount * @dev Used in liquidation (called in cToken.liquidateBorrowFresh) * @param cTokenBorrowed The address of the borrowed cToken * @param cTokenCollateral The address of the collateral cToken * @param actualRepayAmount The amount of cTokenBorrowed underlying to convert into cTokenCollateral tokens * @return (errorCode, number of cTokenCollateral tokens to be seized in a liquidation) */ function liquidateCalculateSeizeTokens(address cTokenBorrowed, address cTokenCollateral, uint actualRepayAmount) external view returns (uint, uint) { /* Read oracle prices for borrowed and collateral markets */ uint priceBorrowedMantissa = oracle.getUnderlyingPrice(CToken(cTokenBorrowed)); uint priceCollateralMantissa = oracle.getUnderlyingPrice(CToken(cTokenCollateral)); if (priceBorrowedMantissa == 0 || priceCollateralMantissa == 0) { return (uint(Error.PRICE_ERROR), 0); } /* * Get the exchange rate and calculate the number of collateral tokens to seize: * seizeAmount = actualRepayAmount * liquidationIncentive * priceBorrowed / priceCollateral * seizeTokens = seizeAmount / exchangeRate * = actualRepayAmount * (liquidationIncentive * priceBorrowed) / (priceCollateral * exchangeRate) */ uint exchangeRateMantissa = CToken(cTokenCollateral).exchangeRateStored(); // Note: reverts on error uint seizeTokens; Exp memory numerator; Exp memory denominator; Exp memory ratio; MathError mathErr; (mathErr, numerator) = mulExp(liquidationIncentiveMantissa, priceBorrowedMantissa); if (mathErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0); } (mathErr, denominator) = mulExp(priceCollateralMantissa, exchangeRateMantissa); if (mathErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0); } (mathErr, ratio) = divExp(numerator, denominator); if (mathErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0); } (mathErr, seizeTokens) = mulScalarTruncate(ratio, actualRepayAmount); if (mathErr != MathError.NO_ERROR) { return (uint(Error.MATH_ERROR), 0); } return (uint(Error.NO_ERROR), seizeTokens); } /*** Admin Functions ***/ /** * @notice Sets a new price oracle for the comptroller * @dev Admin function to set a new price oracle * @return uint 0=success, otherwise a failure (see ErrorReporter.sol for details) */ function _setPriceOracle(PriceOracle newOracle) public returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PRICE_ORACLE_OWNER_CHECK); } // Track the old oracle for the comptroller PriceOracle oldOracle = oracle; // Set comptroller's oracle to newOracle oracle = newOracle; // Emit NewPriceOracle(oldOracle, newOracle) emit NewPriceOracle(oldOracle, newOracle); return uint(Error.NO_ERROR); } /** * @notice Sets the closeFactor used when liquidating borrows * @dev Admin function to set closeFactor * @param newCloseFactorMantissa New close factor, scaled by 1e18 * @return uint 0=success, otherwise a failure. (See ErrorReporter for details) */ function _setCloseFactor(uint newCloseFactorMantissa) external returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_CLOSE_FACTOR_OWNER_CHECK); } Exp memory newCloseFactorExp = Exp({mantissa: newCloseFactorMantissa}); Exp memory lowLimit = Exp({mantissa: closeFactorMinMantissa}); if (lessThanOrEqualExp(newCloseFactorExp, lowLimit)) { return fail(Error.INVALID_CLOSE_FACTOR, FailureInfo.SET_CLOSE_FACTOR_VALIDATION); } Exp memory highLimit = Exp({mantissa: closeFactorMaxMantissa}); if (lessThanExp(highLimit, newCloseFactorExp)) { return fail(Error.INVALID_CLOSE_FACTOR, FailureInfo.SET_CLOSE_FACTOR_VALIDATION); } uint oldCloseFactorMantissa = closeFactorMantissa; closeFactorMantissa = newCloseFactorMantissa; emit NewCloseFactor(oldCloseFactorMantissa, closeFactorMantissa); return uint(Error.NO_ERROR); } /** * @notice Sets the collateralFactor for a market * @dev Admin function to set per-market collateralFactor * @param cToken The market to set the factor on * @param newCollateralFactorMantissa The new collateral factor, scaled by 1e18 * @return uint 0=success, otherwise a failure. (See ErrorReporter for details) */ function _setCollateralFactor(CToken cToken, uint newCollateralFactorMantissa) external returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_COLLATERAL_FACTOR_OWNER_CHECK); } // Verify market is listed Market storage market = markets[address(cToken)]; if (!market.isListed) { return fail(Error.MARKET_NOT_LISTED, FailureInfo.SET_COLLATERAL_FACTOR_NO_EXISTS); } Exp memory newCollateralFactorExp = Exp({mantissa: newCollateralFactorMantissa}); // Check collateral factor <= 0.9 Exp memory highLimit = Exp({mantissa: collateralFactorMaxMantissa}); if (lessThanExp(highLimit, newCollateralFactorExp)) { return fail(Error.INVALID_COLLATERAL_FACTOR, FailureInfo.SET_COLLATERAL_FACTOR_VALIDATION); } // If collateral factor != 0, fail if price == 0 if (newCollateralFactorMantissa != 0 && oracle.getUnderlyingPrice(cToken) == 0) { return fail(Error.PRICE_ERROR, FailureInfo.SET_COLLATERAL_FACTOR_WITHOUT_PRICE); } // Set market's collateral factor to new collateral factor, remember old value uint oldCollateralFactorMantissa = market.collateralFactorMantissa; market.collateralFactorMantissa = newCollateralFactorMantissa; // Emit event with asset, old collateral factor, and new collateral factor emit NewCollateralFactor(cToken, oldCollateralFactorMantissa, newCollateralFactorMantissa); return uint(Error.NO_ERROR); } /** * @notice Sets maxAssets which controls how many markets can be entered * @dev Admin function to set maxAssets * @param newMaxAssets New max assets * @return uint 0=success, otherwise a failure. (See ErrorReporter for details) */ function _setMaxAssets(uint newMaxAssets) external returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_MAX_ASSETS_OWNER_CHECK); } uint oldMaxAssets = maxAssets; maxAssets = newMaxAssets; emit NewMaxAssets(oldMaxAssets, newMaxAssets); return uint(Error.NO_ERROR); } /** * @notice Sets liquidationIncentive * @dev Admin function to set liquidationIncentive * @param newLiquidationIncentiveMantissa New liquidationIncentive scaled by 1e18 * @return uint 0=success, otherwise a failure. (See ErrorReporter for details) */ function _setLiquidationIncentive(uint newLiquidationIncentiveMantissa) external returns (uint) { // Check caller is admin if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_LIQUIDATION_INCENTIVE_OWNER_CHECK); } // Check de-scaled min <= newLiquidationIncentive <= max Exp memory newLiquidationIncentive = Exp({mantissa: newLiquidationIncentiveMantissa}); Exp memory minLiquidationIncentive = Exp({mantissa: liquidationIncentiveMinMantissa}); if (lessThanExp(newLiquidationIncentive, minLiquidationIncentive)) { return fail(Error.INVALID_LIQUIDATION_INCENTIVE, FailureInfo.SET_LIQUIDATION_INCENTIVE_VALIDATION); } Exp memory maxLiquidationIncentive = Exp({mantissa: liquidationIncentiveMaxMantissa}); if (lessThanExp(maxLiquidationIncentive, newLiquidationIncentive)) { return fail(Error.INVALID_LIQUIDATION_INCENTIVE, FailureInfo.SET_LIQUIDATION_INCENTIVE_VALIDATION); } // Save current value for use in log uint oldLiquidationIncentiveMantissa = liquidationIncentiveMantissa; // Set liquidation incentive to new incentive liquidationIncentiveMantissa = newLiquidationIncentiveMantissa; // Emit event with old incentive, new incentive emit NewLiquidationIncentive(oldLiquidationIncentiveMantissa, newLiquidationIncentiveMantissa); return uint(Error.NO_ERROR); } /** * @notice Add the market to the markets mapping and set it as listed * @dev Admin function to set isListed and add support for the market * @param cToken The address of the market (token) to list * @return uint 0=success, otherwise a failure. (See enum Error for details) */ function _supportMarket(CToken cToken) external returns (uint) { if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SUPPORT_MARKET_OWNER_CHECK); } if (markets[address(cToken)].isListed) { return fail(Error.MARKET_ALREADY_LISTED, FailureInfo.SUPPORT_MARKET_EXISTS); } cToken.isCToken(); // Sanity check to make sure its really a CToken markets[address(cToken)] = Market({isListed: true, isComped: false, collateralFactorMantissa: 0}); _addMarketInternal(address(cToken)); emit MarketListed(cToken); return uint(Error.NO_ERROR); } function _addMarketInternal(address cToken) internal { for (uint i = 0; i < allMarkets.length; i ++) { require(allMarkets[i] != CToken(cToken), "market already added"); } allMarkets.push(CToken(cToken)); } /** * @notice Admin function to change the Pause Guardian * @param newPauseGuardian The address of the new Pause Guardian * @return uint 0=success, otherwise a failure. (See enum Error for details) */ function _setPauseGuardian(address newPauseGuardian) public returns (uint) { if (msg.sender != admin) { return fail(Error.UNAUTHORIZED, FailureInfo.SET_PAUSE_GUARDIAN_OWNER_CHECK); } // Save current value for inclusion in log address oldPauseGuardian = pauseGuardian; // Store pauseGuardian with value newPauseGuardian pauseGuardian = newPauseGuardian; // Emit NewPauseGuardian(OldPauseGuardian, NewPauseGuardian) emit NewPauseGuardian(oldPauseGuardian, pauseGuardian); return uint(Error.NO_ERROR); } function _setMintPaused(CToken cToken, bool state) public returns (bool) { require(markets[address(cToken)].isListed, "cannot pause a market that is not listed"); require(msg.sender == pauseGuardian || msg.sender == admin, "only pause guardian and admin can pause"); require(msg.sender == admin || state == true, "only admin can unpause"); mintGuardianPaused[address(cToken)] = state; emit ActionPaused(cToken, "Mint", state); return state; } function _setBorrowPaused(CToken cToken, bool state) public returns (bool) { require(markets[address(cToken)].isListed, "cannot pause a market that is not listed"); require(msg.sender == pauseGuardian || msg.sender == admin, "only pause guardian and admin can pause"); require(msg.sender == admin || state == true, "only admin can unpause"); borrowGuardianPaused[address(cToken)] = state; emit ActionPaused(cToken, "Borrow", state); return state; } function _setTransferPaused(bool state) public returns (bool) { require(msg.sender == pauseGuardian || msg.sender == admin, "only pause guardian and admin can pause"); require(msg.sender == admin || state == true, "only admin can unpause"); transferGuardianPaused = state; emit ActionPaused("Transfer", state); return state; } function _setSeizePaused(bool state) public returns (bool) { require(msg.sender == pauseGuardian || msg.sender == admin, "only pause guardian and admin can pause"); require(msg.sender == admin || state == true, "only admin can unpause"); seizeGuardianPaused = state; emit ActionPaused("Seize", state); return state; } function _become(Unitroller unitroller) public { require(msg.sender == unitroller.admin(), "only unitroller admin can change brains"); require(unitroller._acceptImplementation() == 0, "change not authorized"); } /** * @notice Checks caller is admin, or this contract is becoming the new implementation */ function adminOrInitializing() internal view returns (bool) { return msg.sender == admin || msg.sender == comptrollerImplementation; } /*** Comp Distribution ***/ /** * @notice Recalculate and update COMP speeds for all COMP markets */ function refreshCompSpeeds() public { require(msg.sender == tx.origin, "only externally owned accounts may refresh speeds"); refreshCompSpeedsInternal(); } function refreshCompSpeedsInternal() internal { CToken[] memory allMarkets_ = allMarkets; for (uint i = 0; i < allMarkets_.length; i++) { CToken cToken = allMarkets_[i]; Exp memory borrowIndex = Exp({mantissa: cToken.borrowIndex()}); updateCompSupplyIndex(address(cToken)); updateCompBorrowIndex(address(cToken), borrowIndex); } Exp memory totalUtility = Exp({mantissa: 0}); Exp[] memory utilities = new Exp[](allMarkets_.length); for (uint i = 0; i < allMarkets_.length; i++) { CToken cToken = allMarkets_[i]; if (markets[address(cToken)].isComped) { Exp memory assetPrice = Exp({mantissa: oracle.getUnderlyingPrice(cToken)}); Exp memory utility = mul_(assetPrice, cToken.totalBorrows()); utilities[i] = utility; totalUtility = add_(totalUtility, utility); } } for (uint i = 0; i < allMarkets_.length; i++) { CToken cToken = allMarkets[i]; uint newSpeed = totalUtility.mantissa > 0 ? mul_(compRate, div_(utilities[i], totalUtility)) : 0; compSpeeds[address(cToken)] = newSpeed; emit CompSpeedUpdated(cToken, newSpeed); } } /** * @notice Accrue COMP to the market by updating the supply index * @param cToken The market whose supply index to update */ function updateCompSupplyIndex(address cToken) internal { CompMarketState storage supplyState = compSupplyState[cToken]; uint supplySpeed = compSpeeds[cToken]; uint blockNumber = getBlockNumber(); uint deltaBlocks = sub_(blockNumber, uint(supplyState.block)); if (deltaBlocks > 0 && supplySpeed > 0) { uint supplyTokens = CToken(cToken).totalSupply(); uint compAccrued = mul_(deltaBlocks, supplySpeed); Double memory ratio = supplyTokens > 0 ? fraction(compAccrued, supplyTokens) : Double({mantissa: 0}); Double memory index = add_(Double({mantissa: supplyState.index}), ratio); compSupplyState[cToken] = CompMarketState({ index: safe224(index.mantissa, "new index exceeds 224 bits"), block: safe32(blockNumber, "block number exceeds 32 bits") }); } else if (deltaBlocks > 0) { supplyState.block = safe32(blockNumber, "block number exceeds 32 bits"); } } /** * @notice Accrue COMP to the market by updating the borrow index * @param cToken The market whose borrow index to update */ function updateCompBorrowIndex(address cToken, Exp memory marketBorrowIndex) internal { CompMarketState storage borrowState = compBorrowState[cToken]; uint borrowSpeed = compSpeeds[cToken]; uint blockNumber = getBlockNumber(); uint deltaBlocks = sub_(blockNumber, uint(borrowState.block)); if (deltaBlocks > 0 && borrowSpeed > 0) { uint borrowAmount = div_(CToken(cToken).totalBorrows(), marketBorrowIndex); uint compAccrued = mul_(deltaBlocks, borrowSpeed); Double memory ratio = borrowAmount > 0 ? fraction(compAccrued, borrowAmount) : Double({mantissa: 0}); Double memory index = add_(Double({mantissa: borrowState.index}), ratio); compBorrowState[cToken] = CompMarketState({ index: safe224(index.mantissa, "new index exceeds 224 bits"), block: safe32(blockNumber, "block number exceeds 32 bits") }); } else if (deltaBlocks > 0) { borrowState.block = safe32(blockNumber, "block number exceeds 32 bits"); } } /** * @notice Calculate COMP accrued by a supplier and possibly transfer it to them * @param cToken The market in which the supplier is interacting * @param supplier The address of the supplier to distribute COMP to */ function distributeSupplierComp(address cToken, address supplier, bool distributeAll) internal { CompMarketState storage supplyState = compSupplyState[cToken]; Double memory supplyIndex = Double({mantissa: supplyState.index}); Double memory supplierIndex = Double({mantissa: compSupplierIndex[cToken][supplier]}); compSupplierIndex[cToken][supplier] = supplyIndex.mantissa; if (supplierIndex.mantissa == 0 && supplyIndex.mantissa > 0) { supplierIndex.mantissa = compInitialIndex; } Double memory deltaIndex = sub_(supplyIndex, supplierIndex); uint supplierTokens = CToken(cToken).balanceOf(supplier); uint supplierDelta = mul_(supplierTokens, deltaIndex); uint supplierAccrued = add_(compAccrued[supplier], supplierDelta); compAccrued[supplier] = transferComp(supplier, supplierAccrued, distributeAll ? 0 : compClaimThreshold); emit DistributedSupplierComp(CToken(cToken), supplier, supplierDelta, supplyIndex.mantissa); } /** * @notice Calculate COMP accrued by a borrower and possibly transfer it to them * @dev Borrowers will not begin to accrue until after the first interaction with the protocol. * @param cToken The market in which the borrower is interacting * @param borrower The address of the borrower to distribute COMP to */ function distributeBorrowerComp(address cToken, address borrower, Exp memory marketBorrowIndex, bool distributeAll) internal { CompMarketState storage borrowState = compBorrowState[cToken]; Double memory borrowIndex = Double({mantissa: borrowState.index}); Double memory borrowerIndex = Double({mantissa: compBorrowerIndex[cToken][borrower]}); compBorrowerIndex[cToken][borrower] = borrowIndex.mantissa; if (borrowerIndex.mantissa > 0) { Double memory deltaIndex = sub_(borrowIndex, borrowerIndex); uint borrowerAmount = div_(CToken(cToken).borrowBalanceStored(borrower), marketBorrowIndex); uint borrowerDelta = mul_(borrowerAmount, deltaIndex); uint borrowerAccrued = add_(compAccrued[borrower], borrowerDelta); compAccrued[borrower] = transferComp(borrower, borrowerAccrued, distributeAll ? 0 : compClaimThreshold); emit DistributedBorrowerComp(CToken(cToken), borrower, borrowerDelta, borrowIndex.mantissa); } } /** * @notice Transfer COMP to the user, if they are above the threshold * @dev Note: If there is not enough COMP, we do not perform the transfer all. * @param user The address of the user to transfer COMP to * @param userAccrued The amount of COMP to (possibly) transfer * @return The amount of COMP which was NOT transferred to the user */ function transferComp(address user, uint userAccrued, uint threshold) internal returns (uint) { // if (userAccrued >= threshold && userAccrued > 0) { // Comp comp = Comp(getCompAddress()); // uint compRemaining = comp.balanceOf(address(this)); // if (userAccrued <= compRemaining) { // comp.transfer(user, userAccrued); // return 0; // } // } return userAccrued; } /** * @notice Claim all the comp accrued by holder in all markets * @param holder The address to claim COMP for */ function claimComp(address holder) public { return claimComp(holder, allMarkets); } /** * @notice Claim all the comp accrued by holder in the specified markets * @param holder The address to claim COMP for * @param cTokens The list of markets to claim COMP in */ function claimComp(address holder, CToken[] memory cTokens) public { address[] memory holders = new address[](1); holders[0] = holder; claimComp(holders, cTokens, true, true); } /** * @notice Claim all comp accrued by the holders * @param holders The addresses to claim COMP for * @param cTokens The list of markets to claim COMP in * @param borrowers Whether or not to claim COMP earned by borrowing * @param suppliers Whether or not to claim COMP earned by supplying */ function claimComp(address[] memory holders, CToken[] memory cTokens, bool borrowers, bool suppliers) public { for (uint i = 0; i < cTokens.length; i++) { CToken cToken = cTokens[i]; require(markets[address(cToken)].isListed, "market must be listed"); if (borrowers == true) { Exp memory borrowIndex = Exp({mantissa: cToken.borrowIndex()}); updateCompBorrowIndex(address(cToken), borrowIndex); for (uint j = 0; j < holders.length; j++) { distributeBorrowerComp(address(cToken), holders[j], borrowIndex, true); } } if (suppliers == true) { updateCompSupplyIndex(address(cToken)); for (uint j = 0; j < holders.length; j++) { distributeSupplierComp(address(cToken), holders[j], true); } } } } /*** Comp Distribution Admin ***/ /** * @notice Set the amount of COMP distributed per block * @param compRate_ The amount of COMP wei per block to distribute */ function _setCompRate(uint compRate_) public { require(adminOrInitializing(), "only admin can change comp rate"); uint oldRate = compRate; compRate = compRate_; emit NewCompRate(oldRate, compRate_); refreshCompSpeedsInternal(); } /** * @notice Add markets to compMarkets, allowing them to earn COMP in the flywheel * @param cTokens The addresses of the markets to add */ function _addCompMarkets(address[] memory cTokens) public { require(adminOrInitializing(), "only admin can add comp market"); for (uint i = 0; i < cTokens.length; i++) { _addCompMarketInternal(cTokens[i]); } refreshCompSpeedsInternal(); } function _addCompMarketInternal(address cToken) internal { Market storage market = markets[cToken]; require(market.isListed == true, "comp market is not listed"); require(market.isComped == false, "comp market already added"); market.isComped = true; emit MarketComped(CToken(cToken), true); if (compSupplyState[cToken].index == 0 && compSupplyState[cToken].block == 0) { compSupplyState[cToken] = CompMarketState({ index: compInitialIndex, block: safe32(getBlockNumber(), "block number exceeds 32 bits") }); } if (compBorrowState[cToken].index == 0 && compBorrowState[cToken].block == 0) { compBorrowState[cToken] = CompMarketState({ index: compInitialIndex, block: safe32(getBlockNumber(), "block number exceeds 32 bits") }); } } /** * @notice Remove a market from compMarkets, preventing it from earning COMP in the flywheel * @param cToken The address of the market to drop */ function _dropCompMarket(address cToken) public { require(msg.sender == admin, "only admin can drop comp market"); Market storage market = markets[cToken]; require(market.isComped == true, "market is not a comp market"); market.isComped = false; emit MarketComped(CToken(cToken), false); refreshCompSpeedsInternal(); } /** * @notice Return all of the markets * @dev The automatic getter may be used to access an individual market. * @return The list of market addresses */ function getAllMarkets() public view returns (CToken[] memory) { return allMarkets; } function getBlockNumber() public view returns (uint) { return block.number; } /** * @notice Return the address of the COMP token * @return The address of COMP */ function getCompAddress() public view returns (address) { return 0x69e8b9528CABDA89fe846C67675B5D73d463a916; } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"action","type":"string"},{"indexed":false,"internalType":"bool","name":"pauseState","type":"bool"}],"name":"ActionPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"string","name":"action","type":"string"},{"indexed":false,"internalType":"bool","name":"pauseState","type":"bool"}],"name":"ActionPaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"newSpeed","type":"uint256"}],"name":"CompSpeedUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":false,"internalType":"uint256","name":"compDelta","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"compBorrowIndex","type":"uint256"}],"name":"DistributedBorrowerComp","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":true,"internalType":"address","name":"supplier","type":"address"},{"indexed":false,"internalType":"uint256","name":"compDelta","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"compSupplyIndex","type":"uint256"}],"name":"DistributedSupplierComp","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"error","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"info","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"detail","type":"uint256"}],"name":"Failure","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"bool","name":"isComped","type":"bool"}],"name":"MarketComped","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"MarketEntered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"MarketExited","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"}],"name":"MarketListed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldCloseFactorMantissa","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCloseFactorMantissa","type":"uint256"}],"name":"NewCloseFactor","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract CToken","name":"cToken","type":"address"},{"indexed":false,"internalType":"uint256","name":"oldCollateralFactorMantissa","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCollateralFactorMantissa","type":"uint256"}],"name":"NewCollateralFactor","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldCompRate","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newCompRate","type":"uint256"}],"name":"NewCompRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldLiquidationIncentiveMantissa","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newLiquidationIncentiveMantissa","type":"uint256"}],"name":"NewLiquidationIncentive","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldMaxAssets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newMaxAssets","type":"uint256"}],"name":"NewMaxAssets","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldPauseGuardian","type":"address"},{"indexed":false,"internalType":"address","name":"newPauseGuardian","type":"address"}],"name":"NewPauseGuardian","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"contract PriceOracle","name":"oldPriceOracle","type":"address"},{"indexed":false,"internalType":"contract PriceOracle","name":"newPriceOracle","type":"address"}],"name":"NewPriceOracle","type":"event"},{"constant":false,"inputs":[{"internalType":"address[]","name":"cTokens","type":"address[]"}],"name":"_addCompMarkets","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract Unitroller","name":"unitroller","type":"address"}],"name":"_become","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_borrowGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"}],"name":"_dropCompMarket","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"_mintGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"contract CToken","name":"cToken","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"_setBorrowPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newCloseFactorMantissa","type":"uint256"}],"name":"_setCloseFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract CToken","name":"cToken","type":"address"},{"internalType":"uint256","name":"newCollateralFactorMantissa","type":"uint256"}],"name":"_setCollateralFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"compRate_","type":"uint256"}],"name":"_setCompRate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newLiquidationIncentiveMantissa","type":"uint256"}],"name":"_setLiquidationIncentive","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newMaxAssets","type":"uint256"}],"name":"_setMaxAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract CToken","name":"cToken","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"_setMintPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newPauseGuardian","type":"address"}],"name":"_setPauseGuardian","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract PriceOracle","name":"newOracle","type":"address"}],"name":"_setPriceOracle","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"state","type":"bool"}],"name":"_setSeizePaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"bool","name":"state","type":"bool"}],"name":"_setTransferPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"contract CToken","name":"cToken","type":"address"}],"name":"_supportMarket","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"accountAssets","outputs":[{"internalType":"contract CToken","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"admin","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"allMarkets","outputs":[{"internalType":"contract CToken","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"borrowAmount","type":"uint256"}],"name":"borrowAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"borrowGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"borrowAmount","type":"uint256"}],"name":"borrowVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"contract CToken","name":"cToken","type":"address"}],"name":"checkMembership","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"holder","type":"address"},{"internalType":"contract CToken[]","name":"cTokens","type":"address[]"}],"name":"claimComp","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"holders","type":"address[]"},{"internalType":"contract CToken[]","name":"cTokens","type":"address[]"},{"internalType":"bool","name":"borrowers","type":"bool"},{"internalType":"bool","name":"suppliers","type":"bool"}],"name":"claimComp","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"holder","type":"address"}],"name":"claimComp","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"closeFactorMantissa","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"compAccrued","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"compBorrowState","outputs":[{"internalType":"uint224","name":"index","type":"uint224"},{"internalType":"uint32","name":"block","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"compBorrowerIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"compClaimThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"compInitialIndex","outputs":[{"internalType":"uint224","name":"","type":"uint224"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"compRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"compSpeeds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"compSupplierIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"compSupplyState","outputs":[{"internalType":"uint224","name":"index","type":"uint224"},{"internalType":"uint32","name":"block","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"comptrollerImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address[]","name":"cTokens","type":"address[]"}],"name":"enterMarkets","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenAddress","type":"address"}],"name":"exitMarket","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAccountLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getAllMarkets","outputs":[{"internalType":"contract CToken[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getAssetsIn","outputs":[{"internalType":"contract CToken[]","name":"","type":"address[]"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getBlockNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getCompAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"address","name":"cTokenModify","type":"address"},{"internalType":"uint256","name":"redeemTokens","type":"uint256"},{"internalType":"uint256","name":"borrowAmount","type":"uint256"}],"name":"getHypotheticalAccountLiquidity","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isComptroller","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"repayAmount","type":"uint256"}],"name":"liquidateBorrowAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"actualRepayAmount","type":"uint256"},{"internalType":"uint256","name":"seizeTokens","type":"uint256"}],"name":"liquidateBorrowVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"uint256","name":"actualRepayAmount","type":"uint256"}],"name":"liquidateCalculateSeizeTokens","outputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"liquidationIncentiveMantissa","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"markets","outputs":[{"internalType":"bool","name":"isListed","type":"bool"},{"internalType":"uint256","name":"collateralFactorMantissa","type":"uint256"},{"internalType":"bool","name":"isComped","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"maxAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"minter","type":"address"},{"internalType":"uint256","name":"mintAmount","type":"uint256"}],"name":"mintAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"mintGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"minter","type":"address"},{"internalType":"uint256","name":"actualMintAmount","type":"uint256"},{"internalType":"uint256","name":"mintTokens","type":"uint256"}],"name":"mintVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"oracle","outputs":[{"internalType":"contract PriceOracle","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"pauseGuardian","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"pendingAdmin","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"pendingComptrollerImplementation","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"redeemer","type":"address"},{"internalType":"uint256","name":"redeemTokens","type":"uint256"}],"name":"redeemAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"redeemer","type":"address"},{"internalType":"uint256","name":"redeemAmount","type":"uint256"},{"internalType":"uint256","name":"redeemTokens","type":"uint256"}],"name":"redeemVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"refreshCompSpeeds","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"repayAmount","type":"uint256"}],"name":"repayBorrowAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"payer","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"actualRepayAmount","type":"uint256"},{"internalType":"uint256","name":"borrowerIndex","type":"uint256"}],"name":"repayBorrowVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"seizeTokens","type":"uint256"}],"name":"seizeAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"seizeGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cTokenCollateral","type":"address"},{"internalType":"address","name":"cTokenBorrowed","type":"address"},{"internalType":"address","name":"liquidator","type":"address"},{"internalType":"address","name":"borrower","type":"address"},{"internalType":"uint256","name":"seizeTokens","type":"uint256"}],"name":"seizeVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"transferTokens","type":"uint256"}],"name":"transferAllowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"transferGuardianPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"cToken","type":"address"},{"internalType":"address","name":"src","type":"address"},{"internalType":"address","name":"dst","type":"address"},{"internalType":"uint256","name":"transferTokens","type":"uint256"}],"name":"transferVerify","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
608060405234801561001057600080fd5b50600080546001600160a01b0319163317905561590a80620000336000396000f3fe608060405234801561001057600080fd5b506004361061041c5760003560e01c8063731f0c2b1161022b578063bdcdc25811610130578063dce15449116100b8578063e875544611610087578063e8755446146110ca578063e9af0292146110d2578063eabe7d91146110f8578063ede4edd01461112e578063f851a440146111545761041c565b8063dce1544914611062578063dcfbc0c71461108e578063e4028eee14611096578063e6653f3d146110c25761041c565b8063cc7ebdc4116100ff578063cc7ebdc414610f02578063ce485c5e14610f28578063d02f735114610fc9578063d9226ced1461100f578063da3d454c1461102c5761041c565b8063bdcdc25814610da8578063c299823814610de4578063c488847b14610e85578063ca0af04314610ed45761041c565b80639d1b5a0a116101b3578063abfceffc11610182578063abfceffc14610cec578063ac0b0bb714610d62578063b0772d0b14610d6a578063b21be7fd14610d72578063bb82aa5e14610da05761041c565b80639d1b5a0a14610c92578063a76b3fda14610c9a578063a7f0e23114610cc0578063aa90075414610ce45761041c565b80638c57804e116101fa5780638c57804e14610bcf5780638e8f294b14610bf55780638ebf636414610c3d578063929fe9a114610c5c57806394b2294b14610c8a5761041c565b8063731f0c2b14610b91578063747026c914610bb75780637dc0d1d014610bbf57806387f7630314610bc75761041c565b80634ada90af116103315780635ec88c79116102b95780636a491112116102885780636a49111214610a7e5780636a56947e14610a9b5780636b79c38d14610ad75780636d154ea514610b255780636d35bf9114610b4b5761041c565b80635ec88c79146108c05780635f5af1aa146108e65780635fc7e71e1461090c5780636810dfa6146109525761041c565b80634fd42e17116103005780634fd42e17146107ee57806351dff9891461080b57806352d84d1e1461084757806355ee1fe1146108645780635c7786051461088a5761041c565b80634ada90af1461074e5780634d8e5037146107565780634e79238f1461075e5780634ef4c3e1146107b85761041c565b806326782247116103b45780633bcf7ec1116103835780633bcf7ec1146106885780633c94786f146106b657806341c728b9146106be57806342cbb15c146106fa57806347ef3b3b146107025761041c565b8063267822471461061e5780632d70db7814610626578063317b0b77146106455780633aa729b4146106625761041c565b80631d7b33d7116103f05780631d7b33d7146105445780631ededc911461057c57806324008a62146105be57806324a3d622146105fa5761041c565b80627e3dd21461042157806318c882a51461043d5780631c3db2e01461046b5780631d504dc61461051e575b600080fd5b61042961115c565b604080519115158252519081900360200190f35b6104296004803603604081101561045357600080fd5b506001600160a01b0381351690602001351515611161565b61051c6004803603604081101561048157600080fd5b6001600160a01b038235169190810190604081016020820135600160201b8111156104ab57600080fd5b8201836020820111156104bd57600080fd5b803590602001918460208302840111600160201b831117156104de57600080fd5b919080806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250929550611301945050505050565b005b61051c6004803603602081101561053457600080fd5b50356001600160a01b0316611363565b61056a6004803603602081101561055a57600080fd5b50356001600160a01b03166114c2565b60408051918252519081900360200190f35b61051c600480360360a081101561059257600080fd5b506001600160a01b038135811691602081013582169160408201351690606081013590608001356114d4565b61056a600480360360808110156105d457600080fd5b506001600160a01b038135811691602081013582169160408201351690606001356114db565b6106026115a4565b604080516001600160a01b039092168252519081900360200190f35b6106026115b3565b6104296004803603602081101561063c57600080fd5b503515156115c2565b61056a6004803603602081101561065b57600080fd5b50356116fc565b61051c6004803603602081101561067857600080fd5b50356001600160a01b031661180d565b6104296004803603604081101561069e57600080fd5b506001600160a01b038135169060200135151561193e565b610429611ad9565b61051c600480360360808110156106d457600080fd5b506001600160a01b03813581169160208101359091169060408101359060600135611ae9565b61056a611aef565b61051c600480360360c081101561071857600080fd5b506001600160a01b0381358116916020810135821691604082013581169160608101359091169060808101359060a00135611af4565b61056a611afc565b61051c611b02565b61079a6004803603608081101561077457600080fd5b506001600160a01b03813581169160208101359091169060408101359060600135611b4a565b60408051938452602084019290925282820152519081900360600190f35b61056a600480360360608110156107ce57600080fd5b506001600160a01b03813581169160208101359091169060400135611b84565b61056a6004803603602081101561080457600080fd5b5035611c2f565b61051c6004803603608081101561082157600080fd5b506001600160a01b03813581169160208101359091169060408101359060600135611d23565b6106026004803603602081101561085d57600080fd5b5035611d77565b61056a6004803603602081101561087a57600080fd5b50356001600160a01b0316611d9e565b61051c600480360360608110156108a057600080fd5b506001600160a01b03813581169160208101359091169060400135611e25565b61079a600480360360208110156108d657600080fd5b50356001600160a01b0316611e2a565b61056a600480360360208110156108fc57600080fd5b50356001600160a01b0316611e5f565b61056a600480360360a081101561092257600080fd5b506001600160a01b0381358116916020810135821691604082013581169160608101359091169060800135611ee3565b61051c6004803603608081101561096857600080fd5b810190602081018135600160201b81111561098257600080fd5b82018360208201111561099457600080fd5b803590602001918460208302840111600160201b831117156109b557600080fd5b9190808060200260200160405190810160405280939291908181526020018383602002808284376000920191909152509295949360208101935035915050600160201b811115610a0457600080fd5b820183602082011115610a1657600080fd5b803590602001918460208302840111600160201b83111715610a3757600080fd5b91908080602002602001604051908101604052809392919081815260200183836020028082843760009201919091525092955050505080351515915060200135151561206a565b61051c60048036036020811015610a9457600080fd5b5035612213565b61051c60048036036080811015610ab157600080fd5b506001600160a01b03813581169160208101358216916040820135169060600135611ae9565b610afd60048036036020811015610aed57600080fd5b50356001600160a01b03166122b7565b604080516001600160e01b03909316835263ffffffff90911660208301528051918290030190f35b61042960048036036020811015610b3b57600080fd5b50356001600160a01b03166122e1565b61051c600480360360a0811015610b6157600080fd5b506001600160a01b03813581169160208101358216916040820135811691606081013590911690608001356114d4565b61042960048036036020811015610ba757600080fd5b50356001600160a01b03166122f6565b61056a61230b565b610602612316565b610429612325565b610afd60048036036020811015610be557600080fd5b50356001600160a01b0316612335565b610c1b60048036036020811015610c0b57600080fd5b50356001600160a01b031661235f565b6040805193151584526020840192909252151582820152519081900360600190f35b61042960048036036020811015610c5357600080fd5b50351515612385565b61042960048036036040811015610c7257600080fd5b506001600160a01b03813581169160200135166124be565b61056a6124f1565b6106026124f7565b61056a60048036036020811015610cb057600080fd5b50356001600160a01b031661250f565b610cc861266c565b604080516001600160e01b039092168252519081900360200190f35b61056a61267f565b610d1260048036036020811015610d0257600080fd5b50356001600160a01b0316612685565b60408051602080825283518183015283519192839290830191858101910280838360005b83811015610d4e578181015183820152602001610d36565b505050509050019250505060405180910390f35b61042961270e565b610d1261271e565b61056a60048036036040811015610d8857600080fd5b506001600160a01b0381358116916020013516612780565b61060261279d565b61056a60048036036080811015610dbe57600080fd5b506001600160a01b038135811691602081013582169160408201351690606001356127ac565b610d1260048036036020811015610dfa57600080fd5b810190602081018135600160201b811115610e1457600080fd5b820183602082011115610e2657600080fd5b803590602001918460208302840111600160201b83111715610e4757600080fd5b919080806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250929550612840945050505050565b610ebb60048036036060811015610e9b57600080fd5b506001600160a01b038135811691602081013590911690604001356128d7565b6040805192835260208301919091528051918290030190f35b61056a60048036036040811015610eea57600080fd5b506001600160a01b0381358116916020013516612b4c565b61056a60048036036020811015610f1857600080fd5b50356001600160a01b0316612b69565b61051c60048036036020811015610f3e57600080fd5b810190602081018135600160201b811115610f5857600080fd5b820183602082011115610f6a57600080fd5b803590602001918460208302840111600160201b83111715610f8b57600080fd5b919080806020026020016040519081016040528093929190818152602001838360200280828437600092019190915250929550612b7b945050505050565b61056a600480360360a0811015610fdf57600080fd5b506001600160a01b0381358116916020810135821691604082013581169160608101359091169060800135612c0d565b61056a6004803603602081101561102557600080fd5b5035612dc5565b61056a6004803603606081101561104257600080fd5b506001600160a01b03813581169160208101359091169060400135612e2e565b6106026004803603604081101561107857600080fd5b506001600160a01b03813516906020013561311b565b610602613150565b61056a600480360360408110156110ac57600080fd5b506001600160a01b03813516906020013561315f565b61042961330f565b61056a61331f565b61051c600480360360208110156110e857600080fd5b50356001600160a01b0316613325565b61056a6004803603606081101561110e57600080fd5b506001600160a01b03813581169160208101359091169060400135613389565b61056a6004803603602081101561114457600080fd5b50356001600160a01b03166133c6565b6106026136d9565b600181565b6001600160a01b03821660009081526009602052604081205460ff166111b85760405162461bcd60e51b81526004018080602001828103825260288152602001806157ea6028913960400191505060405180910390fd5b600a546001600160a01b03163314806111db57506000546001600160a01b031633145b6112165760405162461bcd60e51b81526004018080602001828103825260278152602001806158436027913960400191505060405180910390fd5b6000546001600160a01b031633148061123157506001821515145b61127b576040805162461bcd60e51b81526020600482015260166024820152756f6e6c792061646d696e2063616e20756e706175736560501b604482015290519081900360640190fd5b6001600160a01b0383166000818152600c6020908152604091829020805486151560ff199091168117909155825193845283830152606090830181905260069083015265426f72726f7760d01b6080830152517f71aec636243f9709bb0007ae15e9afb8150ab01716d75fd7573be5cc096e03b09181900360a00190a150805b92915050565b60408051600180825281830190925260609160208083019080388339019050509050828160008151811061133157fe5b60200260200101906001600160a01b031690816001600160a01b03168152505061135e818360018061206a565b505050565b806001600160a01b031663f851a4406040518163ffffffff1660e01b815260040160206040518083038186803b15801561139c57600080fd5b505afa1580156113b0573d6000803e3d6000fd5b505050506040513d60208110156113c657600080fd5b50516001600160a01b0316331461140e5760405162461bcd60e51b81526004018080602001828103825260278152602001806158af6027913960400191505060405180910390fd5b806001600160a01b031663c1e803346040518163ffffffff1660e01b8152600401602060405180830381600087803b15801561144957600080fd5b505af115801561145d573d6000803e3d6000fd5b505050506040513d602081101561147357600080fd5b5051156114bf576040805162461bcd60e51b815260206004820152601560248201527418da185b99d9481b9bdd08185d5d1a1bdc9a5e9959605a1b604482015290519081900360640190fd5b50565b600f6020526000908152604090205481565b5050505050565b6001600160a01b03841660009081526009602052604081205460ff166115035750600961159c565b61150b61572a565b6040518060200160405280876001600160a01b031663aa5af0fd6040518163ffffffff1660e01b815260040160206040518083038186803b15801561154f57600080fd5b505afa158015611563573d6000803e3d6000fd5b505050506040513d602081101561157957600080fd5b50519052905061158986826136e8565b6115968685836000613970565b60009150505b949350505050565b600a546001600160a01b031681565b6001546001600160a01b031681565b600a546000906001600160a01b03163314806115e857506000546001600160a01b031633145b6116235760405162461bcd60e51b81526004018080602001828103825260278152602001806158436027913960400191505060405180910390fd5b6000546001600160a01b031633148061163e57506001821515145b611688576040805162461bcd60e51b81526020600482015260166024820152756f6e6c792061646d696e2063616e20756e706175736560501b604482015290519081900360640190fd5b600a8054831515600160b81b810260ff60b81b1990921691909117909155604080516020810192909252808252600582820152645365697a6560d81b6060830152517fef159d9a32b2472e32b098f954f3ce62d232939f1c207070b584df1814de2de09181900360800190a150805b919050565b600080546001600160a01b031633146117225761171b60016004613b5b565b90506116f7565b61172a61572a565b50604080516020810190915282815261174161572a565b50604080516020810190915266b1a2bc2ec5000081526117618282613bc1565b1561177a57611771600580613b5b565b925050506116f7565b61178261572a565b506040805160208101909152670c7d713b49da000081526117a38184613bc9565b156117bd576117b3600580613b5b565b93505050506116f7565b6005805490869055604080518281526020810188905281517f3b9670cf975d26958e754b57098eaa2ac914d8d2a31b83257997b9f346110fd9929181900390910190a160005b9695505050505050565b6000546001600160a01b0316331461186c576040805162461bcd60e51b815260206004820152601f60248201527f6f6e6c792061646d696e2063616e2064726f7020636f6d70206d61726b657400604482015290519081900360640190fd5b6001600160a01b0381166000908152600960205260409020600381015460ff1615156001146118e2576040805162461bcd60e51b815260206004820152601b60248201527f6d61726b6574206973206e6f74206120636f6d70206d61726b65740000000000604482015290519081900360640190fd5b60038101805460ff19169055604080516001600160a01b03841681526000602082015281517f93c1f3e36ed71139f466a4ce8c9751790e2e33f5afb2df0dcfb3aeabe55d5aa2929181900390910190a161193a613bd0565b5050565b6001600160a01b03821660009081526009602052604081205460ff166119955760405162461bcd60e51b81526004018080602001828103825260288152602001806157ea6028913960400191505060405180910390fd5b600a546001600160a01b03163314806119b857506000546001600160a01b031633145b6119f35760405162461bcd60e51b81526004018080602001828103825260278152602001806158436027913960400191505060405180910390fd5b6000546001600160a01b0316331480611a0e57506001821515145b611a58576040805162461bcd60e51b81526020600482015260166024820152756f6e6c792061646d696e2063616e20756e706175736560501b604482015290519081900360640190fd5b6001600160a01b0383166000818152600b6020908152604091829020805486151560ff199091168117909155825193845283830152606090830181905260049083015263135a5b9d60e21b6080830152517f71aec636243f9709bb0007ae15e9afb8150ab01716d75fd7573be5cc096e03b09181900360a00190a150919050565b600a54600160a01b900460ff1681565b50505050565b435b90565b505050505050565b60065481565b333214611b405760405162461bcd60e51b81526004018080602001828103825260318152602001806158126031913960400191505060405180910390fd5b611b48613bd0565b565b600080600080600080611b5f8a8a8a8a613f95565b925092509250826011811115611b7157fe5b95509093509150505b9450945094915050565b6001600160a01b0383166000908152600b602052604081205460ff1615611be3576040805162461bcd60e51b815260206004820152600e60248201526d1b5a5b9d081a5cc81c185d5cd95960921b604482015290519081900360640190fd5b6001600160a01b03841660009081526009602052604090205460ff16611c0d5760095b9050611c28565b611c16846143b0565b611c228484600061462e565b60005b90505b9392505050565b600080546001600160a01b03163314611c4e5761171b6001600b613b5b565b611c5661572a565b506040805160208101909152828152611c6d61572a565b506040805160208101909152670de0b6b3a76400008152611c8e8282613bc9565b15611c9f576117716007600c613b5b565b611ca761572a565b5060408051602081019091526714d1120d7b1600008152611cc88184613bc9565b15611cd9576117b36007600c613b5b565b6006805490869055604080518281526020810188905281517faeba5a6c40a8ac138134bff1aaa65debf25971188a58804bad717f82f0ec1316929181900390910190a16000611803565b80158015611d315750600082115b15611ae9576040805162461bcd60e51b815260206004820152601160248201527072656465656d546f6b656e73207a65726f60781b604482015290519081900360640190fd5b600d8181548110611d8457fe5b6000918252602090912001546001600160a01b0316905081565b600080546001600160a01b03163314611dbd5761171b60016010613b5b565b600480546001600160a01b038481166001600160a01b0319831681179093556040805191909216808252602082019390935281517fd52b2b9b7e9ee655fcb95d2e5b9e0c9f69e7ef2b8e9d2d0ea78402d576d22e22929181900390910190a160009392505050565b61135e565b600080600080600080611e41876000806000613f95565b925092509250826011811115611e5357fe5b97919650945092505050565b600080546001600160a01b03163314611e7e5761171b60016013613b5b565b600a80546001600160a01b038481166001600160a01b0319831617928390556040805192821680845293909116602083015280517f0613b6ee6a04f0d09f390e4d9318894b9f6ac7fd83897cd8d18896ba579c401e9281900390910190a16000611c28565b6001600160a01b03851660009081526009602052604081205460ff161580611f2457506001600160a01b03851660009081526009602052604090205460ff16155b15611f335760095b9050612061565b600080611f3f85614826565b91935090915060009050826011811115611f5557fe5b14611f6f57816011811115611f6657fe5b92505050612061565b80611f7b576003611f66565b6000886001600160a01b03166395dd9193876040518263ffffffff1660e01b815260040180826001600160a01b03166001600160a01b0316815260200191505060206040518083038186803b158015611fd357600080fd5b505afa158015611fe7573d6000803e3d6000fd5b505050506040513d6020811015611ffd57600080fd5b50516040805160208101909152600554815290915060009081906120219084614846565b9092509050600082600381111561203457fe5b1461204857600b5b95505050505050612061565b8087111561205757601161203c565b6000955050505050505b95945050505050565b60005b83518110156114d457600084828151811061208457fe5b6020908102919091018101516001600160a01b0381166000908152600990925260409091205490915060ff166120f9576040805162461bcd60e51b81526020600482015260156024820152741b585c9ad95d081b5d5cdd081899481b1a5cdd1959605a1b604482015290519081900360640190fd5b600184151514156121c15761210c61572a565b6040518060200160405280836001600160a01b031663aa5af0fd6040518163ffffffff1660e01b815260040160206040518083038186803b15801561215057600080fd5b505afa158015612164573d6000803e3d6000fd5b505050506040513d602081101561217a57600080fd5b50519052905061218a82826136e8565b60005b87518110156121be576121b6838983815181106121a657fe5b6020026020010151846001613970565b60010161218d565b50505b6001831515141561220a576121d5816143b0565b60005b865181101561220857612200828883815181106121f157fe5b6020026020010151600161462e565b6001016121d8565b505b5060010161206d565b61221b61489a565b61226c576040805162461bcd60e51b815260206004820152601f60248201527f6f6e6c792061646d696e2063616e206368616e676520636f6d70207261746500604482015290519081900360640190fd5b600e805490829055604080518281526020810184905281517fc227c9272633c3a307d9845bf2bc2509cefb20d655b5f3c1002d8e1e3f22c8b0929181900390910190a161193a613bd0565b6010602052600090815260409020546001600160e01b03811690600160e01b900463ffffffff1682565b600c6020526000908152604090205460ff1681565b600b6020526000908152604090205460ff1681565b66038d7ea4c6800081565b6004546001600160a01b031681565b600a54600160b01b900460ff1681565b6011602052600090815260409020546001600160e01b03811690600160e01b900463ffffffff1682565b60096020526000908152604090208054600182015460039092015460ff91821692911683565b600a546000906001600160a01b03163314806123ab57506000546001600160a01b031633145b6123e65760405162461bcd60e51b81526004018080602001828103825260278152602001806158436027913960400191505060405180910390fd5b6000546001600160a01b031633148061240157506001821515145b61244b576040805162461bcd60e51b81526020600482015260166024820152756f6e6c792061646d696e2063616e20756e706175736560501b604482015290519081900360640190fd5b600a8054831515600160b01b810260ff60b01b1990921691909117909155604080516020810192909252808252600882820152672a3930b739b332b960c11b6060830152517fef159d9a32b2472e32b098f954f3ce62d232939f1c207070b584df1814de2de09181900360800190a15090565b6001600160a01b038082166000908152600960209081526040808320938616835260029093019052205460ff1692915050565b60075481565b7369e8b9528cabda89fe846c67675b5d73d463a91690565b600080546001600160a01b0316331461252e5761171b60016012613b5b565b6001600160a01b03821660009081526009602052604090205460ff161561255b5761171b600a6011613b5b565b816001600160a01b031663fe9c44ae6040518163ffffffff1660e01b815260040160206040518083038186803b15801561259457600080fd5b505afa1580156125a8573d6000803e3d6000fd5b505050506040513d60208110156125be57600080fd5b5050604080516060810182526001808252600060208381018281528486018381526001600160a01b03891684526009909252949091209251835490151560ff19918216178455935191830191909155516003909101805491151591909216179055612628826148c3565b604080516001600160a01b038416815290517fcf583bb0c569eb967f806b11601c4cb93c10310485c67add5f8362c2f212321f9181900360200190a1600092915050565b6ec097ce7bc90715b34b9f100000000081565b600e5481565b60608060086000846001600160a01b03166001600160a01b0316815260200190815260200160002080548060200260200160405190810160405280929190818152602001828054801561270157602002820191906000526020600020905b81546001600160a01b031681526001909101906020018083116126e3575b5093979650505050505050565b600a54600160b81b900460ff1681565b6060600d80548060200260200160405190810160405280929190818152602001828054801561277657602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311612758575b5050505050905090565b601260209081526000928352604080842090915290825290205481565b6002546001600160a01b031681565b600a54600090600160b01b900460ff1615612803576040805162461bcd60e51b81526020600482015260126024820152711d1c985b9cd9995c881a5cc81c185d5cd95960721b604482015290519081900360640190fd5b60006128108686856149a1565b9050801561281f57905061159c565b612828866143b0565b6128348686600061462e565b6115968685600061462e565b6060600082519050606081604051908082528060200260200182016040528015612874578160200160208202803883390190505b50905060005b828110156128cf57600085828151811061289057fe5b602002602001015190506128a48133614a44565b60118111156128af57fe5b8383815181106128bb57fe5b60209081029190910101525060010161287a565b509392505050565b600480546040805163fc57d4df60e01b81526001600160a01b038781169482019490945290516000938493849391169163fc57d4df91602480820192602092909190829003018186803b15801561292d57600080fd5b505afa158015612941573d6000803e3d6000fd5b505050506040513d602081101561295757600080fd5b5051600480546040805163fc57d4df60e01b81526001600160a01b038a8116948201949094529051939450600093929091169163fc57d4df91602480820192602092909190829003018186803b1580156129b057600080fd5b505afa1580156129c4573d6000803e3d6000fd5b505050506040513d60208110156129da57600080fd5b505190508115806129e9575080155b156129fe57600d935060009250612b44915050565b6000866001600160a01b031663182df0f56040518163ffffffff1660e01b815260040160206040518083038186803b158015612a3957600080fd5b505afa158015612a4d573d6000803e3d6000fd5b505050506040513d6020811015612a6357600080fd5b505190506000612a7161572a565b612a7961572a565b612a8161572a565b6000612a8f60065489614b65565b945090506000816003811115612aa157fe5b14612abd57600b5b995060009850612b44975050505050505050565b612ac78787614b65565b935090506000816003811115612ad957fe5b14612ae557600b612aa9565b612aef8484614ba0565b925090506000816003811115612b0157fe5b14612b0d57600b612aa9565b612b17828c614846565b955090506000816003811115612b2957fe5b14612b3557600b612aa9565b60009950939750505050505050505b935093915050565b601360209081526000928352604080842090915290825290205481565b60146020526000908152604090205481565b612b8361489a565b612bd4576040805162461bcd60e51b815260206004820152601e60248201527f6f6e6c792061646d696e2063616e2061646420636f6d70206d61726b65740000604482015290519081900360640190fd5b60005b8151811015612c0457612bfc828281518110612bef57fe5b6020026020010151614bb8565b600101612bd7565b506114bf613bd0565b600a54600090600160b81b900460ff1615612c61576040805162461bcd60e51b815260206004820152600f60248201526e1cd95a5e99481a5cc81c185d5cd959608a1b604482015290519081900360640190fd5b6001600160a01b03861660009081526009602052604090205460ff161580612ca257506001600160a01b03851660009081526009602052604090205460ff16155b15612cae576009611f2c565b846001600160a01b0316635fe3b5676040518163ffffffff1660e01b815260040160206040518083038186803b158015612ce757600080fd5b505afa158015612cfb573d6000803e3d6000fd5b505050506040513d6020811015612d1157600080fd5b505160408051635fe3b56760e01b815290516001600160a01b0392831692891691635fe3b567916004808301926020929190829003018186803b158015612d5757600080fd5b505afa158015612d6b573d6000803e3d6000fd5b505050506040513d6020811015612d8157600080fd5b50516001600160a01b031614612d98576002611f2c565b612da1866143b0565b612dad8684600061462e565b612db98685600061462e565b60009695505050505050565b600080546001600160a01b03163314612de45761171b6001600d613b5b565b6007805490839055604080518281526020810185905281517f7093cf1eb653f749c3ff531d6df7f92764536a7fa0d13530cd26e070780c32ea929181900390910190a16000611c28565b6001600160a01b0383166000908152600c602052604081205460ff1615612e8f576040805162461bcd60e51b815260206004820152601060248201526f189bdc9c9bddc81a5cc81c185d5cd95960821b604482015290519081900360640190fd5b6001600160a01b03841660009081526009602052604090205460ff16612eb6576009611c06565b6001600160a01b038085166000908152600960209081526040808320938716835260029093019052205460ff16612fa657336001600160a01b03851614612f3c576040805162461bcd60e51b815260206004820152601560248201527439b2b73232b91036bab9ba1031329031aa37b5b2b760591b604482015290519081900360640190fd5b6000612f483385614a44565b90506000816011811115612f5857fe5b14612f7157806011811115612f6957fe5b915050611c28565b6001600160a01b038086166000908152600960209081526040808320938816835260029093019052205460ff16612fa457fe5b505b600480546040805163fc57d4df60e01b81526001600160a01b03888116948201949094529051929091169163fc57d4df91602480820192602092909190829003018186803b158015612ff757600080fd5b505afa15801561300b573d6000803e3d6000fd5b505050506040513d602081101561302157600080fd5b505161302e57600d611c06565b60008061303e8587600087613f95565b9193509091506000905082601181111561305457fe5b1461306e5781601181111561306557fe5b92505050611c28565b801561307b576004613065565b61308361572a565b6040518060200160405280886001600160a01b031663aa5af0fd6040518163ffffffff1660e01b815260040160206040518083038186803b1580156130c757600080fd5b505afa1580156130db573d6000803e3d6000fd5b505050506040513d60208110156130f157600080fd5b50519052905061310187826136e8565b61310e8787836000613970565b6000979650505050505050565b6008602052816000526040600020818154811061313457fe5b6000918252602090912001546001600160a01b03169150829050565b6003546001600160a01b031681565b600080546001600160a01b031633146131855761317e60016006613b5b565b90506112fb565b6001600160a01b0383166000908152600960205260409020805460ff166131ba576131b260096007613b5b565b9150506112fb565b6131c261572a565b5060408051602081019091528381526131d961572a565b506040805160208101909152670c7d713b49da000081526131fa8183613bc9565b156132155761320b60066008613b5b565b93505050506112fb565b841580159061329e5750600480546040805163fc57d4df60e01b81526001600160a01b038a8116948201949094529051929091169163fc57d4df91602480820192602092909190829003018186803b15801561327057600080fd5b505afa158015613284573d6000803e3d6000fd5b505050506040513d602081101561329a57600080fd5b5051155b156132af5761320b600d6009613b5b565b60018301805490869055604080516001600160a01b03891681526020810183905280820188905290517f70483e6592cd5182d45ac970e05bc62cdcc90e9d8ef2c2dbe686cf383bcd7fc59181900360600190a16000979650505050505050565b600a54600160a81b900460ff1681565b60055481565b6114bf81600d80548060200260200160405190810160405280929190818152602001828054801561337f57602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311613361575b5050505050611301565b6000806133978585856149a1565b905080156133a6579050611c28565b6133af856143b0565b6133bb8585600061462e565b600095945050505050565b6000808290506000806000836001600160a01b031663c37f68e2336040518263ffffffff1660e01b815260040180826001600160a01b03166001600160a01b0316815260200191505060806040518083038186803b15801561342757600080fd5b505afa15801561343b573d6000803e3d6000fd5b505050506040513d608081101561345157600080fd5b5080516020820151604090920151909450909250905082156134a45760405162461bcd60e51b815260040180806020018281038252602581526020018061586a6025913960400191505060405180910390fd5b80156134c1576134b6600c6002613b5b565b9450505050506116f7565b60006134ce8733856149a1565b905080156134ef576134e3600e600383614ed3565b955050505050506116f7565b6001600160a01b0385166000908152600960209081526040808320338452600281019092529091205460ff1661352e57600096505050505050506116f7565b3360009081526002820160209081526040808320805460ff1916905560088252918290208054835181840281018401909452808452606093928301828280156135a057602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311613582575b5050835193945083925060009150505b828110156135f557896001600160a01b03168482815181106135ce57fe5b60200260200101516001600160a01b031614156135ed578091506135f5565b6001016135b0565b508181106135ff57fe5b33600090815260086020526040902080548190600019810190811061362057fe5b9060005260206000200160009054906101000a90046001600160a01b031681838154811061364a57fe5b600091825260209091200180546001600160a01b0319166001600160a01b0392909216919091179055805461368382600019830161573d565b50604080516001600160a01b038c16815233602082015281517fe699a64c18b07ac5b7301aa273f36a2287239eb9501d81950672794afba29a0d929181900390910190a160009c9b505050505050505050505050565b6000546001600160a01b031681565b6001600160a01b0382166000908152601160209081526040808320600f9092528220549091613715611aef565b8354909150600090613735908390600160e01b900463ffffffff16614f39565b90506000811180156137475750600083115b156139165760006137bc876001600160a01b03166347bd37186040518163ffffffff1660e01b815260040160206040518083038186803b15801561378a57600080fd5b505afa15801561379e573d6000803e3d6000fd5b505050506040513d60208110156137b457600080fd5b505187614f73565b905060006137ca8386614f91565b90506137d461572a565b600083116137f157604051806020016040528060008152506137fb565b6137fb8284614fd3565b905061380561572a565b604080516020810190915288546001600160e01b031681526138279083615011565b9050604051806040016040528061387783600001516040518060400160405280601a81526020017f6e657720696e6465782065786365656473203232342062697473000000000000815250615036565b6001600160e01b031681526020016138b2886040518060400160405280601c815260200160008051602061588f8339815191528152506150d0565b63ffffffff9081169091526001600160a01b038c166000908152601160209081526040909120835181549490920151909216600160e01b026001600160e01b039182166001600160e01b0319909416939093171691909117905550611af492505050565b8015611af457613949826040518060400160405280601c815260200160008051602061588f8339815191528152506150d0565b845463ffffffff91909116600160e01b026001600160e01b03909116178455505050505050565b6001600160a01b038416600090815260116020526040902061399061572a565b50604080516020810190915281546001600160e01b031681526139b161572a565b5060408051602080820183526001600160a01b03808a16600090815260138352848120918a1680825282845294812080548552865195909152915291909155805115613b52576139ff61572a565b613a098383615125565b90506000613a98896001600160a01b03166395dd91938a6040518263ffffffff1660e01b815260040180826001600160a01b03166001600160a01b0316815260200191505060206040518083038186803b158015613a6657600080fd5b505afa158015613a7a573d6000803e3d6000fd5b505050506040513d6020811015613a9057600080fd5b505188614f73565b90506000613aa6828461514a565b6001600160a01b038a1660009081526014602052604081205491925090613acd9083615179565b9050613aee8a828a613ae65766038d7ea4c68000613ae9565b60005b6151af565b6001600160a01b03808c1660008181526014602090815260409182902094909455895181518781529485015280519193928f16927f1fc3ecc087d8d2d15e23d0032af5a47059c3892d003d8e139fdcb6bb327c99a6929081900390910190a3505050505b50505050505050565b60007f45b96fe442630264581b197e84bbada861235052c5a1aadfff9ea4e40a969aa0836011811115613b8a57fe5b836013811115613b9657fe5b604080519283526020830191909152600082820152519081900360600190a1826011811115611c2857fe5b519051111590565b5190511090565b6060600d805480602002602001604051908101604052809291908181526020018280548015613c2857602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311613c0a575b50939450600093505050505b8151811015613cee576000828281518110613c4b57fe5b60200260200101519050613c5d61572a565b6040518060200160405280836001600160a01b031663aa5af0fd6040518163ffffffff1660e01b815260040160206040518083038186803b158015613ca157600080fd5b505afa158015613cb5573d6000803e3d6000fd5b505050506040513d6020811015613ccb57600080fd5b505190529050613cda826143b0565b613ce482826136e8565b5050600101613c34565b50613cf761572a565b60405180602001604052806000815250905060608251604051908082528060200260200182016040528015613d4657816020015b613d3361572a565b815260200190600190039081613d2b5790505b50905060005b8351811015613ecc576000848281518110613d6357fe5b6020908102919091018101516001600160a01b0381166000908152600990925260409091206003015490915060ff1615613ec357613d9f61572a565b60408051602080820180845260045463fc57d4df60e01b9091526001600160a01b03868116602485015293519293849391169163fc57d4df916044808601929190818703018186803b158015613df457600080fd5b505afa158015613e08573d6000803e3d6000fd5b505050506040513d6020811015613e1e57600080fd5b505190529050613e2c61572a565b613e9a82846001600160a01b03166347bd37186040518163ffffffff1660e01b815260040160206040518083038186803b158015613e6957600080fd5b505afa158015613e7d573d6000803e3d6000fd5b505050506040513d6020811015613e9357600080fd5b50516151b5565b905080858581518110613ea957fe5b6020026020010181905250613ebe8682615011565b955050505b50600101613d4c565b5060005b8351811015611ae9576000600d8281548110613ee857fe5b600091825260208220015485516001600160a01b039091169250613f0d576000613f35565b613f35600e54613f30868681518110613f2257fe5b6020026020010151886151d6565b615209565b6001600160a01b0383166000818152600f60209081526040918290208490558151848152915193945091927f2ab93f65628379309f36cb125e90d7c902454a545c4f8b8cb0794af75c24b807929181900390910190a25050600101613ed0565b6000806000613fa2615761565b6001600160a01b03881660009081526008602090815260408083208054825181850281018501909352808352849360609392919083018282801561400f57602002820191906000526020600020905b81546001600160a01b03168152600190910190602001808311613ff1575b50939450600093505050505b815181101561436b57600082828151811061403257fe5b60200260200101519050806001600160a01b031663c37f68e28e6040518263ffffffff1660e01b815260040180826001600160a01b03166001600160a01b0316815260200191505060806040518083038186803b15801561409257600080fd5b505afa1580156140a6573d6000803e3d6000fd5b505050506040513d60808110156140bc57600080fd5b508051602082015160408084015160609485015160808c0152938a019390935291880191909152945084156141025750600f975060009650869550611b7a945050505050565b60408051602080820183526001600160a01b0380851660008181526009845285902060010154845260c08b01939093528351808301855260808b0151815260e08b015260048054855163fc57d4df60e01b815291820194909452935192169263fc57d4df9260248083019392829003018186803b15801561418257600080fd5b505afa158015614196573d6000803e3d6000fd5b505050506040513d60208110156141ac57600080fd5b505160a087018190526141d05750600d975060009650869550611b7a945050505050565b604080516020810190915260a08701518152610100870181905260c087015160e08801516141fd92615222565b6101208801529350600084600381111561421357fe5b1461422f5750600b975060009650869550611b7a945050505050565b6142478661012001518760400151886000015161527a565b87529350600084600381111561425957fe5b146142755750600b975060009650869550611b7a945050505050565b61428d8661010001518760600151886020015161527a565b6020880152935060008460038111156142a257fe5b146142be5750600b975060009650869550611b7a945050505050565b8b6001600160a01b0316816001600160a01b03161415614362576142ec8661012001518c886020015161527a565b60208801529350600084600381111561430157fe5b1461431d5750600b975060009650869550611b7a945050505050565b6143318661010001518b886020015161527a565b60208801529350600084600381111561434657fe5b146143625750600b975060009650869550611b7a945050505050565b5060010161401b565b50602084015184511115614392575050506020810151905160009450039150829050611b7a565b5050815160209092015160009550859450919091039150611b7a9050565b6001600160a01b0381166000908152601060209081526040808320600f90925282205490916143dd611aef565b83549091506000906143fd908390600160e01b900463ffffffff16614f39565b905060008111801561440f5750600083115b156145d5576000856001600160a01b03166318160ddd6040518163ffffffff1660e01b815260040160206040518083038186803b15801561444f57600080fd5b505afa158015614463573d6000803e3d6000fd5b505050506040513d602081101561447957600080fd5b5051905060006144898386614f91565b905061449361572a565b600083116144b057604051806020016040528060008152506144ba565b6144ba8284614fd3565b90506144c461572a565b604080516020810190915288546001600160e01b031681526144e69083615011565b9050604051806040016040528061453683600001516040518060400160405280601a81526020017f6e657720696e6465782065786365656473203232342062697473000000000000815250615036565b6001600160e01b03168152602001614571886040518060400160405280601c815260200160008051602061588f8339815191528152506150d0565b63ffffffff9081169091526001600160a01b038b166000908152601060209081526040909120835181549490920151909216600160e01b026001600160e01b039182166001600160e01b03199094169390931716919091179055506114d492505050565b80156114d457614608826040518060400160405280601c815260200160008051602061588f8339815191528152506150d0565b845463ffffffff91909116600160e01b026001600160e01b039091161784555050505050565b6001600160a01b038316600090815260106020526040902061464e61572a565b50604080516020810190915281546001600160e01b0316815261466f61572a565b5060408051602080820183526001600160a01b038089166000908152601283528481209189168082528284529481208054855286519590915291529190915580511580156146bd5750815115155b156146d5576ec097ce7bc90715b34b9f100000000081525b6146dd61572a565b6146e78383615125565b90506000876001600160a01b03166370a08231886040518263ffffffff1660e01b815260040180826001600160a01b03166001600160a01b0316815260200191505060206040518083038186803b15801561474157600080fd5b505afa158015614755573d6000803e3d6000fd5b505050506040513d602081101561476b57600080fd5b50519050600061477b828461514a565b6001600160a01b038916600090815260146020526040812054919250906147a29083615179565b90506147bb89828a613ae65766038d7ea4c68000613ae9565b6001600160a01b03808b1660008181526014602090815260409182902094909455895181518781529485015280519193928e16927f2caecd17d02f56fa897705dcc740da2d237c373f70686f4e0d9bd3bf0400ea7a929081900390910190a350505050505050505050565b6000806000614839846000806000613f95565b9250925092509193909250565b600080600061485361572a565b61485d86866152c7565b9092509050600082600381111561487057fe5b146148815750915060009050614893565b600061488c8261532f565b9350935050505b9250929050565b600080546001600160a01b03163314806148be57506002546001600160a01b031633145b905090565b60005b600d5481101561494e57816001600160a01b0316600d82815481106148e757fe5b6000918252602090912001546001600160a01b03161415614946576040805162461bcd60e51b81526020600482015260146024820152731b585c9ad95d08185b1c9958591e48185919195960621b604482015290519081900360640190fd5b6001016148c6565b50600d80546001810182556000919091527fd7b6990105719101dabeb77144f2a3385c8033acd3af97e9423a695e81ad1eb50180546001600160a01b0319166001600160a01b0392909216919091179055565b6001600160a01b03831660009081526009602052604081205460ff166149c8576009611c06565b6001600160a01b038085166000908152600960209081526040808320938716835260029093019052205460ff16614a00576000611c06565b600080614a108587866000613f95565b91935090915060009050826011811115614a2657fe5b14614a375781601181111561306557fe5b8015612db9576004613065565b6001600160a01b0382166000908152600960205260408120805460ff16614a6f5760099150506112fb565b6001600160a01b038316600090815260028201602052604090205460ff16151560011415614aa15760009150506112fb565b6007546001600160a01b03841660009081526008602052604090205410614acc5760109150506112fb565b6001600160a01b0380841660008181526002840160209081526040808320805460ff19166001908117909155600883528184208054918201815584529282902090920180549489166001600160a01b031990951685179055815193845283019190915280517f3ab23ab0d51cccc0c3085aec51f99228625aa1a922b3a8ca89a26b0f2027a1a59281900390910190a15060009392505050565b6000614b6f61572a565b614b9560405180602001604052808681525060405180602001604052808681525061533e565b915091509250929050565b6000614baa61572a565b83518351614b959190615427565b6001600160a01b0381166000908152600960205260409020805460ff161515600114614c2b576040805162461bcd60e51b815260206004820152601960248201527f636f6d70206d61726b6574206973206e6f74206c697374656400000000000000604482015290519081900360640190fd5b600381015460ff1615614c85576040805162461bcd60e51b815260206004820152601960248201527f636f6d70206d61726b657420616c726561647920616464656400000000000000604482015290519081900360640190fd5b60038101805460ff19166001908117909155604080516001600160a01b0385168152602081019290925280517f93c1f3e36ed71139f466a4ce8c9751790e2e33f5afb2df0dcfb3aeabe55d5aa29281900390910190a16001600160a01b0382166000908152601060205260409020546001600160e01b0316158015614d2d57506001600160a01b038216600090815260106020526040902054600160e01b900463ffffffff16155b15614dea5760405180604001604052806ec097ce7bc90715b34b9f10000000006001600160e01b03168152602001614d8f614d66611aef565b6040518060400160405280601c815260200160008051602061588f8339815191528152506150d0565b63ffffffff9081169091526001600160a01b0384166000908152601060209081526040909120835181549490920151909216600160e01b026001600160e01b039182166001600160e01b031990941693909317169190911790555b6001600160a01b0382166000908152601160205260409020546001600160e01b0316158015614e3c57506001600160a01b038216600090815260116020526040902054600160e01b900463ffffffff16155b1561193a5760405180604001604052806ec097ce7bc90715b34b9f10000000006001600160e01b03168152602001614e75614d66611aef565b63ffffffff9081169091526001600160a01b0384166000908152601160209081526040909120835181549490920151909216600160e01b026001600160e01b039182166001600160e01b031990941693909317169190911790555050565b60007f45b96fe442630264581b197e84bbada861235052c5a1aadfff9ea4e40a969aa0846011811115614f0257fe5b846013811115614f0e57fe5b604080519283526020830191909152818101859052519081900360600190a1836011811115611c2557fe5b6000611c288383604051806040016040528060158152602001747375627472616374696f6e20756e646572666c6f7760581b8152506154d7565b6000611c28614f8a84670de0b6b3a7640000614f91565b8351615531565b6000611c2883836040518060400160405280601781526020017f6d756c7469706c69636174696f6e206f766572666c6f77000000000000000000815250615564565b614fdb61572a565b6040518060200160405280615008615002866ec097ce7bc90715b34b9f1000000000614f91565b85615531565b90529392505050565b61501961572a565b604051806020016040528061500885600001518560000151615179565b600081600160e01b84106150c85760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561508d578181015183820152602001615075565b50505050905090810190601f1680156150ba5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b509192915050565b600081600160201b84106150c85760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561508d578181015183820152602001615075565b61512d61572a565b604051806020016040528061500885600001518560000151614f39565b60006ec097ce7bc90715b34b9f100000000061516a848460000151614f91565b8161517157fe5b049392505050565b6000611c288383604051806040016040528060118152602001706164646974696f6e206f766572666c6f7760781b8152506155e3565b50919050565b6151bd61572a565b6040518060200160405280615008856000015185614f91565b6151de61572a565b60405180602001604052806150086152028660000151670de0b6b3a7640000614f91565b8551615531565b6000670de0b6b3a764000061516a848460000151614f91565b600061522c61572a565b600061523661572a565b615240878761533e565b9092509050600082600381111561525357fe5b14615262579092509050612b44565b61526c818661533e565b935093505050935093915050565b600080600061528761572a565b61529187876152c7565b909250905060008260038111156152a457fe5b146152b55750915060009050612b44565b61526c6152c18261532f565b86615638565b60006152d161572a565b6000806152e286600001518661565e565b909250905060008260038111156152f557fe5b1461531457506040805160208101909152600081529092509050614893565b60408051602081019091529081526000969095509350505050565b51670de0b6b3a7640000900490565b600061534861572a565b60008061535d8660000151866000015161565e565b9092509050600082600381111561537057fe5b1461538f57506040805160208101909152600081529092509050614893565b6000806153a46706f05b59d3b2000084615638565b909250905060008260038111156153b757fe5b146153d957506040805160208101909152600081529094509250614893915050565b6000806153ee83670de0b6b3a764000061569d565b9092509050600082600381111561540157fe5b1461540857fe5b604080516020810190915290815260009a909950975050505050505050565b600061543161572a565b60008061544686670de0b6b3a764000061565e565b9092509050600082600381111561545957fe5b1461547857506040805160208101909152600081529092509050614893565b600080615485838861569d565b9092509050600082600381111561549857fe5b146154ba57506040805160208101909152600081529094509250614893915050565b604080516020810190915290815260009890975095505050505050565b600081848411156155295760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561508d578181015183820152602001615075565b505050900390565b6000611c2883836040518060400160405280600e81526020016d646976696465206279207a65726f60901b8152506156c8565b6000831580615571575082155b1561557e57506000611c28565b8383028385828161558b57fe5b041483906155da5760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561508d578181015183820152602001615075565b50949350505050565b600083830182858210156155da5760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561508d578181015183820152602001615075565b60008083830184811061565057600092509050614893565b506002915060009050614893565b6000808361567157506000905080614893565b8383028385828161567e57fe5b041461569257506002915060009050614893565b600092509050614893565b600080826156b15750600190506000614893565b60008385816156bc57fe5b04915091509250929050565b600081836157175760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561508d578181015183820152602001615075565b5082848161572157fe5b04949350505050565b6040518060200160405280600081525090565b81548183558181111561135e5760008381526020902061135e9181019083016157cb565b60405180610140016040528060008152602001600081526020016000815260200160008152602001600081526020016000815260200161579f61572a565b81526020016157ac61572a565b81526020016157b961572a565b81526020016157c661572a565b905290565b611af191905b808211156157e557600081556001016157d1565b509056fe63616e6e6f742070617573652061206d61726b65742074686174206973206e6f74206c69737465646f6e6c792065787465726e616c6c79206f776e6564206163636f756e7473206d61792072656672657368207370656564736f6e6c7920706175736520677561726469616e20616e642061646d696e2063616e207061757365657869744d61726b65743a206765744163636f756e74536e617073686f74206661696c6564626c6f636b206e756d62657220657863656564732033322062697473000000006f6e6c7920756e6974726f6c6c65722061646d696e2063616e206368616e676520627261696e73a265627a7a7231582031df1e77f2266eaead8b6cf006d57c112622229fe5bbf12532d21e650a05841964736f6c63430005100032
Deployed Bytecode
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
Deployed Bytecode Sourcemap
132307:58439:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;132307:58439:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;192:41;;;:::i;:::-;;;;;;;;;;;;;;;;;;176203:509;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;176203:509:0;;;;;;;;;;:::i;186147:209::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;186147:209:0;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;186147:209:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;186147:209:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;186147:209:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;186147:209:0;;-1:-1:-1;186147:209:0;;-1:-1:-1;;;;;186147:209:0:i;:::-;;177483:234;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;177483:234:0;-1:-1:-1;;;;;177483:234:0;;:::i;112645:42::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;112645:42:0;-1:-1:-1;;;;;112645:42:0;;:::i;:::-;;;;;;;;;;;;;;;;149676:458;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;149676:458:0;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;148708:646::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;148708:646:0;;;;;;;;;;;;;;;;;;;;;;:::i;111781:28::-;;;:::i;:::-;;;;-1:-1:-1;;;;;111781:28:0;;;;;;;;;;;;;;109555:27;;;:::i;177106:369::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;177106:369:0;;;;:::i;168017:1051::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;168017:1051:0;;:::i;189732:383::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;189732:383:0;-1:-1:-1;;;;;189732:383:0;;:::i;175692:503::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;175692:503:0;;;;;;;;;;:::i;111816:31::-;;;:::i;142648:362::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;142648:362:0;;;;;;;;;;;;;;;;;;;;;;:::i;190413:91::-;;;:::i;152355:546::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;152355:546:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;110262:40::-;;;:::i;178116:178::-;;;:::i;159580:408::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;159580:408:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;141713:603;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;141713:603:0;;;;;;;;;;;;;;;;;:::i;172078:1504::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;172078:1504:0;;:::i;145134:349::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;145134:349:0;;;;;;;;;;;;;;;;;;;;;;:::i;112428:26::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;112428:26:0;;:::i;167144:572::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;167144:572:0;-1:-1:-1;;;;;167144:572:0;;:::i;147889:322::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;147889:322:0;;;;;;;;;;;;;;;;;:::i;158201:268::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;158201:268:0;-1:-1:-1;;;;;158201:268:0;;:::i;175077:607::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;175077:607:0;-1:-1:-1;;;;;175077:607:0;;:::i;150588:1293::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;150588:1293:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;186699:951::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;186699:951:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;186699:951:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;186699:951:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;186699:951:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;186699:951:0;;;;;;;;-1:-1:-1;186699:951:0;;-1:-1:-1;;;;;5:28;;2:2;;;46:1;43;36:12;2:2;186699:951:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;186699:951:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;186699:951:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;186699:951:0;;-1:-1:-1;;;;186699:951:0;;;;;-1:-1:-1;186699:951:0;;;;;;:::i;187850:283::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;187850:283:0;;:::i;156856:345::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;156856:345:0;;;;;;;;;;;;;;;;;;;;;;:::i;112758:58::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;112758:58:0;-1:-1:-1;;;;;112758:58:0;;:::i;:::-;;;;-1:-1:-1;;;;;112758:58:0;;;;;;;;;;;;;;;;;;;;;;112030:52;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;112030:52:0;-1:-1:-1;;;;;112030:52:0;;:::i;154811:475::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;154811:475:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;111973:50::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;111973:50:0;-1:-1:-1;;;;;111973:50:0;;:::i;134763:::-;;;:::i;109963:25::-;;;:::i;111894:34::-;;;:::i;112887:58::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;112887:58:0;-1:-1:-1;;;;;112887:58:0;;:::i;111461:41::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;111461:41:0;-1:-1:-1;;;;;111461:41:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;176720:378;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;176720:378:0;;;;:::i;136397:163::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;136397:163:0;;;;;;;;;;:::i;110432:21::-;;;:::i;190619:124::-;;;:::i;173909:672::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;173909:672:0;-1:-1:-1;;;;;173909:672:0;;:::i;134875:47::-;;;:::i;:::-;;;;-1:-1:-1;;;;;134875:47:0;;;;;;;;;;;;;;112539:20;;;:::i;135946:174::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;135946:174:0;-1:-1:-1;;;;;135946:174:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;135946:174:0;;;;;;;;;;;;;;;;;111935:31;;;:::i;190306:99::-;;;:::i;113065:69::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;113065:69:0;;;;;;;;;;:::i;109651:40::-;;;:::i;155753:778::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;155753:778:0;;;;;;;;;;;;;;;;;;;;;;:::i;136826:379::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;136826:379:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;136826:379:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;136826:379:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;136826:379:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;136826:379:0;;-1:-1:-1;136826:379:0;;-1:-1:-1;;;;;136826:379:0:i;164888:1991::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;164888:1991:0;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;113254:69;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;113254:69:0;;;;;;;;;;:::i;113403:43::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;113403:43:0;-1:-1:-1;;;;;113403:43:0;;:::i;188305:296::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;188305:296:0;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;188305:296:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;188305:296:0;;;;;;101:9:-1;95:2;81:12;77:21;67:8;63:36;60:51;-1:-1;;;25:12;22:29;11:108;8:2;;;132:1;129;122:12;8:2;188305:296:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;188305:296:0;;-1:-1:-1;188305:296:0;;-1:-1:-1;;;;;188305:296:0:i;153364:986::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;153364:986:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;171363:414::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;171363:414:0;;:::i;145924:1658::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;145924:1658:0;;;;;;;;;;;;;;;;;:::i;110560:49::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;110560:49:0;;;;;;;;:::i;109761:47::-;;;:::i;169442:1639::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;169442:1639:0;;;;;;;;:::i;111854:33::-;;;:::i;110110:31::-;;;:::i;185834:97::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;185834:97:0;-1:-1:-1;;;;;185834:97:0;;:::i;143461:452::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;143461:452:0;;;;;;;;;;;;;;;;;:::i;139057:2177::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;139057:2177:0;-1:-1:-1;;;;;139057:2177:0;;:::i;109454:20::-;;;:::i;192:41::-;229:4;192:41;:::o;176203:509::-;-1:-1:-1;;;;;176297:24:0;;176272:4;176297:24;;;:7;:24;;;;;:33;;;176289:86;;;;-1:-1:-1;;;176289:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;176408:13;;-1:-1:-1;;;;;176408:13:0;176394:10;:27;;:50;;-1:-1:-1;176439:5:0;;-1:-1:-1;;;;;176439:5:0;176425:10;:19;176394:50;176386:102;;;;-1:-1:-1;;;176386:102:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;176521:5;;-1:-1:-1;;;;;176521:5:0;176507:10;:19;;:36;;-1:-1:-1;176539:4:0;176530:13;;;;176507:36;176499:71;;;;;-1:-1:-1;;;176499:71:0;;;;;;;;;;;;-1:-1:-1;;;176499:71:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;176583:37:0;;;;;;:20;:37;;;;;;;;;:45;;;;;-1:-1:-1;;176583:45:0;;;;;;;;176644:37;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;176644:37:0;;;;;;;;;;;;;;-1:-1:-1;176699:5:0;176203:509;;;;;:::o;186147:209::-;186252:16;;;186266:1;186252:16;;;;;;;;;186225:24;;186252:16;;;;;;105:10:-1;186252:16:0;88:34:-1;136:17;;-1:-1;186252:16:0;186225:43;;186292:6;186279:7;186287:1;186279:10;;;;;;;;;;;;;:19;-1:-1:-1;;;;;186279:19:0;;;-1:-1:-1;;;;;186279:19:0;;;;;186309:39;186319:7;186328;186337:4;186343;186309:9;:39::i;:::-;186147:209;;;:::o;177483:234::-;177563:10;-1:-1:-1;;;;;177563:16:0;;:18;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;177563:18:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;177563:18:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;177563:18:0;-1:-1:-1;;;;;177549:32:0;:10;:32;177541:84;;;;-1:-1:-1;;;177541:84:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;177644:10;-1:-1:-1;;;;;177644:32:0;;:34;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;177644:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;177644:34:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;177644:34:0;:39;177636:73;;;;;-1:-1:-1;;;177636:73:0;;;;;;;;;;;;-1:-1:-1;;;177636:73:0;;;;;;;;;;;;;;;177483:234;:::o;112645:42::-;;;;;;;;;;;;;:::o;149676:458::-;;;;;;:::o;148708:646::-;-1:-1:-1;;;;;148974:15:0;;148858:4;148974:15;;;:7;:15;;;;;:24;;;148969:94;;-1:-1:-1;149027:23:0;149015:36;;148969:94;149112:22;;:::i;:::-;149137:45;;;;;;;;149159:6;-1:-1:-1;;;;;149152:26:0;;:28;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;149152:28:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;149152:28:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;149152:28:0;149137:45;;149112:70;-1:-1:-1;149193:42:0;149215:6;149112:70;149193:21;:42::i;:::-;149246:60;149269:6;149277:8;149287:11;149300:5;149246:22;:60::i;:::-;149331:14;149319:27;;;148708:646;;;;;;;:::o;111781:28::-;;;-1:-1:-1;;;;;111781:28:0;;:::o;109555:27::-;;;-1:-1:-1;;;;;109555:27:0;;:::o;177106:369::-;177198:13;;177159:4;;-1:-1:-1;;;;;177198:13:0;177184:10;:27;;:50;;-1:-1:-1;177229:5:0;;-1:-1:-1;;;;;177229:5:0;177215:10;:19;177184:50;177176:102;;;;-1:-1:-1;;;177176:102:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;177311:5;;-1:-1:-1;;;;;177311:5:0;177297:10;:19;;:36;;-1:-1:-1;177329:4:0;177320:13;;;;177297:36;177289:71;;;;;-1:-1:-1;;;177289:71:0;;;;;;;;;;;;-1:-1:-1;;;177289:71:0;;;;;;;;;;;;;;;177373:19;:27;;;;;-1:-1:-1;;;177373:27:0;;-1:-1:-1;;;;177373:27:0;;;;;;;;;;177416:28;;;;;;;;;;;;;;;;;;-1:-1:-1;;;177416:28:0;;;;;;;;;;;;;;-1:-1:-1;177462:5:0;177106:369;;;;:::o;168017:1051::-;168089:4;168158:5;;-1:-1:-1;;;;;168158:5:0;168144:10;:19;168140:125;;168187:66;168192:18;168212:40;168187:4;:66::i;:::-;168180:73;;;;168140:125;168277:28;;:::i;:::-;-1:-1:-1;168308:39:0;;;;;;;;;;;;168358:19;;:::i;:::-;-1:-1:-1;168380:39:0;;;;;;;;;135048:7;168380:39;;168434:47;168453:17;168380:39;168434:18;:47::i;:::-;168430:160;;;168505:73;168510:26;168538:39;168505:4;:73::i;:::-;168498:80;;;;;;168430:160;168602:20;;:::i;:::-;-1:-1:-1;168625:39:0;;;;;;;;;135175:6;168625:39;;168679:41;168625:39;168702:17;168679:11;:41::i;:::-;168675:154;;;168744:73;168749:26;168777:39;168744:4;:73::i;:::-;168737:80;;;;;;;168675:154;168871:19;;;168901:44;;;;168961:59;;;;;;;;;;;;;;;;;;;;;;;;;169045:14;169040:20;169033:27;168017:1051;-1:-1:-1;;;;;;168017:1051:0:o;189732:383::-;189813:5;;-1:-1:-1;;;;;189813:5:0;189799:10;:19;189791:63;;;;;-1:-1:-1;;;189791:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;189891:15:0;;189867:21;189891:15;;;:7;:15;;;;;189925;;;;;;:23;;:15;:23;189917:63;;;;;-1:-1:-1;;;189917:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;189993:15;;;:23;;-1:-1:-1;;189993:23:0;;;190032:35;;;-1:-1:-1;;;;;190032:35:0;;;;190011:5;190032:35;;;;;;;;;;;;;;;;;190080:27;:25;:27::i;:::-;189732:383;;:::o;175692:503::-;-1:-1:-1;;;;;175784:24:0;;175759:4;175784:24;;;:7;:24;;;;;:33;;;175776:86;;;;-1:-1:-1;;;175776:86:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;175895:13;;-1:-1:-1;;;;;175895:13:0;175881:10;:27;;:50;;-1:-1:-1;175926:5:0;;-1:-1:-1;;;;;175926:5:0;175912:10;:19;175881:50;175873:102;;;;-1:-1:-1;;;175873:102:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;176008:5;;-1:-1:-1;;;;;176008:5:0;175994:10;:19;;:36;;-1:-1:-1;176026:4:0;176017:13;;;;175994:36;175986:71;;;;;-1:-1:-1;;;175986:71:0;;;;;;;;;;;;-1:-1:-1;;;175986:71:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;176070:35:0;;;;;;:18;:35;;;;;;;;;:43;;;;;-1:-1:-1;;176070:43:0;;;;;;;;176129:35;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;176129:35:0;;;;;;;;;;;;;;-1:-1:-1;176182:5:0;175692:503;-1:-1:-1;175692:503:0:o;111816:31::-;;;-1:-1:-1;;;111816:31:0;;;;;:::o;142648:362::-;;;;;:::o;190413:91::-;190484:12;190413:91;;:::o;152355:546::-;;;;;;;:::o;110262:40::-;;;;:::o;178116:178::-;178171:10;178185:9;178171:23;178163:85;;;;-1:-1:-1;;;178163:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;178259:27;:25;:27::i;:::-;178116:178::o;159580:408::-;159756:4;159762;159768;159786:9;159797:14;159813;159831:98;159871:7;159887:12;159902;159916;159831:39;:98::i;:::-;159785:144;;;;;;159953:3;159948:9;;;;;;;;159940:40;-1:-1:-1;159959:9:0;;-1:-1:-1;159970:9:0;-1:-1:-1;;159580:408:0;;;;;;;;;:::o;141713:603::-;-1:-1:-1;;;;;141907:26:0;;141801:4;141907:26;;;:18;:26;;;;;;;;141906:27;141898:54;;;;;-1:-1:-1;;;141898:54:0;;;;;;;;;;;;-1:-1:-1;;;141898:54:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;142045:15:0;;;;;;:7;:15;;;;;:24;;;142040:94;;142098:23;142093:29;142086:36;;;;142040:94;142183:29;142205:6;142183:21;:29::i;:::-;142223:45;142246:6;142254;142262:5;142223:22;:45::i;:::-;142293:14;142288:20;142281:27;;141713:603;;;;;;:::o;172078:1504::-;172168:4;172237:5;;-1:-1:-1;;;;;172237:5:0;172223:10;:19;172219:134;;172266:75;172271:18;172291:49;172266:4;:75::i;172219:134::-;172431:34;;:::i;:::-;-1:-1:-1;172468:48:0;;;;;;;;;;;;172527:34;;:::i;:::-;-1:-1:-1;172564:48:0;;;;;;;;;135456:6;172564:48;;172627:61;172639:23;172564:48;172627:11;:61::i;:::-;172623:192;;;172712:91;172717:35;172754:48;172712:4;:91::i;172623:192::-;172827:34;;:::i;:::-;-1:-1:-1;172864:48:0;;;;;;;;;135607:6;172864:48;;172927:61;172864:48;172964:23;172927:11;:61::i;:::-;172923:192;;;173012:91;173017:35;173054:48;173012:4;:91::i;172923:192::-;173212:28;;;173308:62;;;;173445:89;;;;;;;;;;;;;;;;;;;;;;;;;173559:14;173554:20;;145134:349;145383:17;;:37;;;;;145419:1;145404:12;:16;145383:37;145379:97;;;145437:27;;;-1:-1:-1;;;145437:27:0;;;;;;;;;;;;-1:-1:-1;;;145437:27:0;;;;;;;;;;;;;;112428:26;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;112428:26:0;;-1:-1:-1;112428:26:0;:::o;167144:572::-;167208:4;167277:5;;-1:-1:-1;;;;;167277:5:0;167263:10;:19;167259:125;;167306:66;167311:18;167331:40;167306:4;:66::i;167259:125::-;167473:6;;;-1:-1:-1;;;;;167542:18:0;;;-1:-1:-1;;;;;;167542:18:0;;;;;;;167632:36;;;167473:6;;;;167632:36;;;;;;;;;;;;;;;;;;;;;;;167693:14;167681:27;167144:572;-1:-1:-1;;;167144:572:0:o;147889:322::-;148145:59;;158201:268;158268:4;158274;158280;158298:9;158309:14;158325;158343:65;158383:7;158399:1;158403;158406;158343:39;:65::i;:::-;158297:111;;;;;;158434:3;158429:9;;;;;;;;158421:40;158440:9;;-1:-1:-1;158440:9:0;-1:-1:-1;158201:268:0;-1:-1:-1;;;158201:268:0:o;175077:607::-;175146:4;175181:5;;-1:-1:-1;;;;;175181:5:0;175167:10;:19;175163:127;;175210:68;175215:18;175235:42;175210:4;:68::i;175163:127::-;175381:13;;;-1:-1:-1;;;;;175467:32:0;;;-1:-1:-1;;;;;;175467:32:0;;;;;;;175587:49;;;175381:13;;;175587:49;;;175622:13;;;;175587:49;;;;;;;;;;;;;;;;175661:14;175656:20;;150588:1293;-1:-1:-1;;;;;150870:23:0;;150790:4;150870:23;;;:7;:23;;;;;:32;;;150869:33;;:72;;-1:-1:-1;;;;;;150907:25:0;;;;;;:7;:25;;;;;:34;;;150906:35;150869:72;150865:141;;;150970:23;150965:29;150958:36;;;;150865:141;151095:9;151108:14;151126:37;151154:8;151126:27;:37::i;:::-;151094:69;;-1:-1:-1;151094:69:0;;-1:-1:-1;151185:14:0;;-1:-1:-1;151178:3:0;:21;;;;;;;;;151174:70;;151228:3;151223:9;;;;;;;;151216:16;;;;;;151174:70;151258:14;151254:88;;151301:28;151296:34;;151254:88;151443:18;151471:14;-1:-1:-1;;;;;151464:42:0;;151507:8;151464:52;;;;;;;;;;;;;-1:-1:-1;;;;;151464:52:0;-1:-1:-1;;;;;151464:52:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;151464:52:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;151464:52:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;151464:52:0;151582:36;;;151464:52;151582:36;;;;;151597:19;;151582:36;;151464:52;;-1:-1:-1;151528:17:0;;;;151564:70;;151464:52;151564:17;:70::i;:::-;151527:107;;-1:-1:-1;151527:107:0;-1:-1:-1;151660:18:0;151649:7;:29;;;;;;;;;151645:91;;151707:16;151702:22;151695:29;;;;;;;;;151645:91;151764:8;151750:11;:22;151746:88;;;151801:20;151796:26;;151746:88;151858:14;151846:27;;;;;;;150588:1293;;;;;;;;:::o;186699:951::-;186824:6;186819:824;186840:7;:14;186836:1;:18;186819:824;;;186876:13;186892:7;186900:1;186892:10;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;186925:24:0;;;;;;:7;:24;;;;;;;:33;186892:10;;-1:-1:-1;186925:33:0;;186917:67;;;;;-1:-1:-1;;;186917:67:0;;;;;;;;;;;;-1:-1:-1;;;186917:67:0;;;;;;;;;;;;;;;187016:4;187003:17;;;;186999:363;;;187041:22;;:::i;:::-;187066:37;;;;;;;;187081:6;-1:-1:-1;;;;;187081:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;187081:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;187081:20:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;187081:20:0;187066:37;;187041:62;-1:-1:-1;187122:51:0;187152:6;187041:62;187122:21;:51::i;:::-;187197:6;187192:155;187213:7;:14;187209:1;:18;187192:155;;;187257:70;187288:6;187297:7;187305:1;187297:10;;;;;;;;;;;;;;187309:11;187322:4;187257:22;:70::i;:::-;187229:3;;187192:155;;;;186999:363;;187393:4;187380:17;;;;187376:256;;;187418:38;187448:6;187418:21;:38::i;:::-;187480:6;187475:142;187496:7;:14;187492:1;:18;187475:142;;;187540:57;187571:6;187580:7;187588:1;187580:10;;;;;;;;;;;;;;187592:4;187540:22;:57::i;:::-;187512:3;;187475:142;;;;187376:256;-1:-1:-1;186856:3:0;;186819:824;;187850:283;187914:21;:19;:21::i;:::-;187906:65;;;;;-1:-1:-1;;;187906:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;187999:8;;;188018:20;;;;188054:31;;;;;;;;;;;;;;;;;;;;;;;;;188098:27;:25;:27::i;112758:58::-;;;;;;;;;;;;-1:-1:-1;;;;;112758:58:0;;;-1:-1:-1;;;112758:58:0;;;;;:::o;112030:52::-;;;;;;;;;;;;;;;:::o;111973:50::-;;;;;;;;;;;;;;;:::o;134763:::-;134805:8;134763:50;:::o;109963:25::-;;;-1:-1:-1;;;;;109963:25:0;;:::o;111894:34::-;;;-1:-1:-1;;;111894:34:0;;;;;:::o;112887:58::-;;;;;;;;;;;;-1:-1:-1;;;;;112887:58:0;;;-1:-1:-1;;;112887:58:0;;;;;:::o;111461:41::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;176720:378::-;176815:13;;176776:4;;-1:-1:-1;;;;;176815:13:0;176801:10;:27;;:50;;-1:-1:-1;176846:5:0;;-1:-1:-1;;;;;176846:5:0;176832:10;:19;176801:50;176793:102;;;;-1:-1:-1;;;176793:102:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;176928:5;;-1:-1:-1;;;;;176928:5:0;176914:10;:19;;:36;;-1:-1:-1;176946:4:0;176937:13;;;;176914:36;176906:71;;;;;-1:-1:-1;;;176906:71:0;;;;;;;;;;;;-1:-1:-1;;;176906:71:0;;;;;;;;;;;;;;;176990:22;:30;;;;;-1:-1:-1;;;176990:30:0;;-1:-1:-1;;;;176990:30:0;;;;;;;;;;177036:31;;;;;;;;;;;;;;;;;;-1:-1:-1;;;177036:31:0;;;;;;;;;;;;;;-1:-1:-1;177085:5:0;176720:378::o;136397:163::-;-1:-1:-1;;;;;136501:24:0;;;136477:4;136501:24;;;:7;:24;;;;;;;;:51;;;;;:42;;;;:51;;;;;;136397:163;;;;:::o;110432:21::-;;;;:::o;190619:124::-;190693:42;190619:124;:::o;173909:672::-;173966:4;174001:5;;-1:-1:-1;;;;;174001:5:0;173987:10;:19;173983:123;;174030:64;174035:18;174055:38;174030:4;:64::i;173983:123::-;-1:-1:-1;;;;;174122:24:0;;;;;;:7;:24;;;;;:33;;;174118:141;;;174179:68;174184:27;174213:33;174179:4;:68::i;174118:141::-;174271:6;-1:-1:-1;;;;;174271:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;174271:17:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;174271:17:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;174377:70:0;;;;;;;;174395:4;174377:70;;;-1:-1:-1;174271:17:0;174377:70;;;;;;;;;;;;-1:-1:-1;;;;;174350:24:0;;;;:7;:24;;;;;;;:97;;;;;;;-1:-1:-1;;174350:97:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;174460:35;174366:6;174460:18;:35::i;:::-;174513:20;;;-1:-1:-1;;;;;174513:20:0;;;;;;;;;;;;;;;174558:14;174546:27;173909:672;-1:-1:-1;;173909:672:0:o;134875:47::-;134918:4;134875:47;:::o;112539:20::-;;;;:::o;135946:174::-;136007:15;136035:24;136062:13;:22;136076:7;-1:-1:-1;;;;;136062:22:0;-1:-1:-1;;;;;136062:22:0;;;;;;;;;;;;136035:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;136035:49:0;;;;;;;;;;;;;;;;-1:-1:-1;136035:49:0;;135946:174;-1:-1:-1;;;;;;;135946:174:0:o;111935:31::-;;;-1:-1:-1;;;111935:31:0;;;;;:::o;190306:99::-;190352:15;190387:10;190380:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;190380:17:0;;;;;;;;;;;;;;;;;;;;;;;190306:99;:::o;113065:69::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;109651:40::-;;;-1:-1:-1;;;;;109651:40:0;;:::o;155753:778::-;155965:22;;155859:4;;-1:-1:-1;;;155965:22:0;;;;155964:23;155956:54;;;;;-1:-1:-1;;;155956:54:0;;;;;;;;;;;;-1:-1:-1;;;155956:54:0;;;;;;;;;;;;;;;156145:12;156160:50;156182:6;156190:3;156195:14;156160:21;:50::i;:::-;156145:65;-1:-1:-1;156225:31:0;;156221:78;;156280:7;-1:-1:-1;156273:14:0;;156221:78;156348:29;156370:6;156348:21;:29::i;:::-;156388:42;156411:6;156419:3;156424:5;156388:22;:42::i;:::-;156441;156464:6;156472:3;156477:5;156441:22;:42::i;136826:379::-;136890:13;136916:8;136927:7;:14;136916:25;;136954:21;136989:3;136978:15;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;136978:15:0;-1:-1:-1;136954:39:0;-1:-1:-1;137009:6:0;137004:167;137025:3;137021:1;:7;137004:167;;;137050:13;137073:7;137081:1;137073:10;;;;;;;;;;;;;;137050:34;;137119:39;137139:6;137147:10;137119:19;:39::i;:::-;137114:45;;;;;;;;137101:7;137109:1;137101:10;;;;;;;;;;;;;;;;;:58;-1:-1:-1;137030:3:0;;137004:167;;;-1:-1:-1;137190:7:0;136826:379;-1:-1:-1;;;136826:379:0:o;164888:1991::-;165146:6;;;:49;;;-1:-1:-1;;;165146:49:0;;-1:-1:-1;;;;;165146:49:0;;;;;;;;;;;;165024:4;;;;;;165146:6;;;:25;;:49;;;;;;;;;;;;;;;:6;:49;;;5:2:-1;;;;30:1;27;20:12;5:2;165146:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;165146:49:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;165146:49:0;165237:6;;;:51;;;-1:-1:-1;;;165237:51:0;;-1:-1:-1;;;;;165237:51:0;;;;;;;;;;;;165146:49;;-1:-1:-1;165206:28:0;;165237:6;;;;;:25;;:51;;;;;165146:49;;165237:51;;;;;;;;:6;:51;;;5:2:-1;;;;30:1;27;20:12;5:2;165237:51:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;165237:51:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;165237:51:0;;-1:-1:-1;165303:26:0;;;:58;;-1:-1:-1;165333:28:0;;165303:58;165299:126;;;165391:17;165378:35;-1:-1:-1;165411:1:0;;-1:-1:-1;165378:35:0;;-1:-1:-1;;165378:35:0;165299:126;165818:25;165853:16;-1:-1:-1;;;;;165846:43:0;;:45;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;165846:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;165846:45:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;165846:45:0;;-1:-1:-1;165928:16:0;165955:20;;:::i;:::-;165986:22;;:::i;:::-;166019:16;;:::i;:::-;166046:17;166099:59;166106:28;;166136:21;166099:6;:59::i;:::-;166076:82;-1:-1:-1;166076:82:0;-1:-1:-1;166184:18:0;166173:7;:29;;;;;;;;;166169:96;;166232:16;166227:22;166219:34;-1:-1:-1;166251:1:0;;-1:-1:-1;166219:34:0;;-1:-1:-1;;;;;;;;166219:34:0;166169:96;166302:53;166309:23;166334:20;166302:6;:53::i;:::-;166277:78;-1:-1:-1;166277:78:0;-1:-1:-1;166381:18:0;166370:7;:29;;;;;;;;;166366:96;;166429:16;166424:22;;166366:96;166493:30;166500:9;166511:11;166493:6;:30::i;:::-;166474:49;-1:-1:-1;166474:49:0;-1:-1:-1;166549:18:0;166538:7;:29;;;;;;;;;166534:96;;166597:16;166592:22;;166534:96;166667:43;166685:5;166692:17;166667;:43::i;:::-;166642:68;-1:-1:-1;166642:68:0;-1:-1:-1;166736:18:0;166725:7;:29;;;;;;;;;166721:96;;166784:16;166779:22;;166721:96;166842:14;166829:42;-1:-1:-1;166859:11:0;;-1:-1:-1;;;;;;;;164888:1991:0;;;;;;;:::o;113254:69::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;113403:43::-;;;;;;;;;;;;;:::o;188305:296::-;188382:21;:19;:21::i;:::-;188374:64;;;;;-1:-1:-1;;;188374:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;188456:6;188451:103;188472:7;:14;188468:1;:18;188451:103;;;188508:34;188531:7;188539:1;188531:10;;;;;;;;;;;;;;188508:22;:34::i;:::-;188488:3;;188451:103;;;;188566:27;:25;:27::i;153364:986::-;153662:19;;153556:4;;-1:-1:-1;;;153662:19:0;;;;153661:20;153653:48;;;;;-1:-1:-1;;;153653:48:0;;;;;;;;;;;;-1:-1:-1;;;153653:48:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;153778:25:0;;;;;;:7;:25;;;;;:34;;;153777:35;;:72;;-1:-1:-1;;;;;;153817:23:0;;;;;;:7;:23;;;;;:32;;;153816:33;153777:72;153773:141;;;153878:23;153873:29;;153773:141;153979:14;-1:-1:-1;;;;;153972:34:0;;:36;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;153972:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;153972:36:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;153972:36:0;153930:38;;;-1:-1:-1;;;153930:38:0;;;;-1:-1:-1;;;;;153930:78:0;;;;:36;;;;;:38;;;;;153972:36;;153930:38;;;;;;;:36;:38;;;5:2:-1;;;;30:1;27;20:12;5:2;153930:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;153930:38:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;153930:38:0;-1:-1:-1;;;;;153930:78:0;;153926:150;;154037:26;154032:32;;153926:150;154125:39;154147:16;154125:21;:39::i;:::-;154175:57;154198:16;154216:8;154226:5;154175:22;:57::i;:::-;154243:59;154266:16;154284:10;154296:5;154243:22;:59::i;:::-;154327:14;154315:27;153364:986;-1:-1:-1;;;;;;153364:986:0:o;171363:414::-;171423:4;171492:5;;-1:-1:-1;;;;;171492:5:0;171478:10;:19;171474:123;;171521:64;171526:18;171546:38;171521:4;:64::i;171474:123::-;171629:9;;;171649:24;;;;171689:40;;;;;;;;;;;;;;;;;;;;;;;;;171754:14;171749:20;;145924:1658;-1:-1:-1;;;;;146124:28:0;;146018:4;146124:28;;;:20;:28;;;;;;;;146123:29;146115:58;;;;;-1:-1:-1;;;146115:58:0;;;;;;;;;;;;-1:-1:-1;;;146115:58:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;146191:15:0;;;;;;:7;:15;;;;;:24;;;146186:94;;146244:23;146239:29;;146186:94;-1:-1:-1;;;;;146297:15:0;;;;;;;:7;:15;;;;;;;;:43;;;;;:33;;;;:43;;;;;;146292:574;;146443:10;-1:-1:-1;;;;;146443:20:0;;;146435:54;;;;;-1:-1:-1;;;146435:54:0;;;;;;;;;;;;-1:-1:-1;;;146435:54:0;;;;;;;;;;;;;;;146560:9;146572:49;146599:10;146612:8;146572:19;:49::i;:::-;146560:61;-1:-1:-1;146647:14:0;146640:3;:21;;;;;;;;;146636:78;;146694:3;146689:9;;;;;;;;146682:16;;;;;146636:78;-1:-1:-1;;;;;146810:15:0;;;;;;;:7;:15;;;;;;;;:43;;;;;:33;;;;:43;;;;;;146803:51;;;;146292:574;;146882:6;;;:41;;;-1:-1:-1;;;146882:41:0;;-1:-1:-1;;;;;146882:41:0;;;;;;;;;;;;:6;;;;;:25;;:41;;;;;;;;;;;;;;;:6;:41;;;5:2:-1;;;;30:1;27;20:12;5:2;146882:41:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;146882:41:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;146882:41:0;146878:109;;146957:17;146952:23;;146878:109;147000:9;147013:14;147031:82;147071:8;147088:6;147097:1;147100:12;147031:39;:82::i;:::-;146999:114;;-1:-1:-1;146999:114:0;;-1:-1:-1;147135:14:0;;-1:-1:-1;147128:3:0;:21;;;;;;;;;147124:70;;147178:3;147173:9;;;;;;;;147166:16;;;;;;147124:70;147208:13;;147204:87;;147250:28;147245:34;;147204:87;147340:22;;:::i;:::-;147365:45;;;;;;;;147387:6;-1:-1:-1;;;;;147380:26:0;;:28;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;147380:28:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;147380:28:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;147380:28:0;147365:45;;147340:70;-1:-1:-1;147421:42:0;147443:6;147340:70;147421:21;:42::i;:::-;147474:60;147497:6;147505:8;147515:11;147528:5;147474:22;:60::i;:::-;147559:14;147547:27;145924:1658;-1:-1:-1;;;;;;;145924:1658:0:o;110560:49::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;110560:49:0;;-1:-1:-1;110560:49:0;;-1:-1:-1;110560:49:0:o;109761:47::-;;;-1:-1:-1;;;;;109761:47:0;;:::o;169442:1639::-;169539:4;169608:5;;-1:-1:-1;;;;;169608:5:0;169594:10;:19;169590:130;;169637:71;169642:18;169662:45;169637:4;:71::i;:::-;169630:78;;;;169590:130;-1:-1:-1;;;;;169792:24:0;;169768:21;169792:24;;;:7;:24;;;;;169832:15;;;;169827:130;;169871:74;169876:23;169901:43;169871:4;:74::i;:::-;169864:81;;;;;169827:130;169969:33;;:::i;:::-;-1:-1:-1;170005:44:0;;;;;;;;;;;;170105:20;;:::i;:::-;-1:-1:-1;170128:44:0;;;;;;;;;135308:6;170128:44;;170187:46;170128:44;170210:22;170187:11;:46::i;:::-;170183:169;;;170257:83;170262:31;170295:44;170257:4;:83::i;:::-;170250:90;;;;;;;170183:169;170426:32;;;;;:74;;-1:-1:-1;170462:6:0;;;:33;;;-1:-1:-1;;;170462:33:0;;-1:-1:-1;;;;;170462:33:0;;;;;;;;;;;;:6;;;;;:25;;:33;;;;;;;;;;;;;;;:6;:33;;;5:2:-1;;;;30:1;27;20:12;5:2;170462:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;170462:33:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;170462:33:0;:38;170426:74;170422:186;;;170524:72;170529:17;170548:47;170524:4;:72::i;170422:186::-;170743:31;;;;;170785:61;;;;170948:85;;;-1:-1:-1;;;;;170948:85:0;;;;;;;;;;;;;;;;;;;;;;;;;;;171058:14;171046:27;169442:1639;-1:-1:-1;;;;;;;169442:1639:0:o;111854:33::-;;;-1:-1:-1;;;111854:33:0;;;;;:::o;110110:31::-;;;;:::o;185834:97::-;185894:29;185904:6;185912:10;185894:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;185894:29:0;;;;;;;;;;;;;;;;;;;;;:9;:29::i;143461:452::-;143555:4;143572:12;143587:53;143609:6;143617:8;143627:12;143587:21;:53::i;:::-;143572:68;-1:-1:-1;143655:31:0;;143651:78;;143710:7;-1:-1:-1;143703:14:0;;143651:78;143778:29;143800:6;143778:21;:29::i;:::-;143818:47;143841:6;143849:8;143859:5;143818:22;:47::i;:::-;143890:14;143878:27;143461:452;-1:-1:-1;;;;;143461:452:0:o;139057:2177::-;139118:4;139135:13;139158;139135:37;;139263:9;139274:15;139291;139312:6;-1:-1:-1;;;;;139312:25:0;;139338:10;139312:37;;;;;;;;;;;;;-1:-1:-1;;;;;139312:37:0;-1:-1:-1;;;;;139312:37:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;139312:37:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;139312:37:0;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;139312:37:0;;;;;;;;;;;;;-1:-1:-1;139312:37:0;;-1:-1:-1;139312:37:0;-1:-1:-1;139368:9:0;;139360:59;;;;-1:-1:-1;;;139360:59:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;139517:15;;139513:127;;139556:72;139561:28;139591:36;139556:4;:72::i;:::-;139549:79;;;;;;;;139513:127;139733:12;139748:60;139770:13;139785:10;139797;139748:21;:60::i;:::-;139733:75;-1:-1:-1;139823:12:0;;139819:123;;139859:71;139870:15;139887:33;139922:7;139859:10;:71::i;:::-;139852:78;;;;;;;;;139819:123;-1:-1:-1;;;;;139984:24:0;;139954:27;139984:24;;;:7;:24;;;;;;;;140133:10;140102:42;;:30;;;:42;;;;;;;;;140097:103;;140173:14;140161:27;;;;;;;;;;140097:103;140304:10;140273:42;;;;:30;;;:42;;;;;;;;140266:49;;-1:-1:-1;;140266:49:0;;;140475:13;:25;;;;;;140443:57;;;;;;;;;;;;;;;;;:29;;:57;;;140475:25;140443:57;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;140443:57:0;;;;;;;;;;;;;;;;-1:-1:-1;;140522:20:0;;140443:57;;-1:-1:-1;140522:20:0;;-1:-1:-1;140511:8:0;;-1:-1:-1;;140585:162:0;140606:3;140602:1;:7;140585:162;;;140655:6;-1:-1:-1;;;;;140635:26:0;:13;140649:1;140635:16;;;;;;;;;;;;;;-1:-1:-1;;;;;140635:26:0;;140631:105;;;140695:1;140682:14;;140715:5;;140631:105;140611:3;;140585:162;;;;140876:3;140863:10;:16;140856:24;;;;141026:10;140982:27;141012:25;;;:13;:25;;;;;141084:17;;141012:25;;-1:-1:-1;;141084:21:0;;;141073:33;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;141073:33:0;141048:10;141059;141048:22;;;;;;;;;;;;;;;;;:58;;-1:-1:-1;;;;;;141048:58:0;-1:-1:-1;;;;;141048:58:0;;;;;;;;;;141117:19;;;;-1:-1:-1;;141117:19:0;;;:::i;:::-;-1:-1:-1;141154:32:0;;;-1:-1:-1;;;;;141154:32:0;;;;141175:10;141154:32;;;;;;;;;;;;;;;;;141211:14;141199:27;139057:2177;-1:-1:-1;;;;;;;;;;;;139057:2177:0:o;109454:20::-;;;-1:-1:-1;;;;;109454:20:0;;:::o;180993:1103::-;-1:-1:-1;;;;;181128:23:0;;181090:35;181128:23;;;:15;:23;;;;;;;;181181:10;:18;;;;;;181128:23;;181229:16;:14;:16::i;:::-;181298:17;;181210:35;;-1:-1:-1;181256:16:0;;181275:42;;181210:35;;-1:-1:-1;;;181298:17:0;;;;181275:4;:42::i;:::-;181256:61;;181346:1;181332:11;:15;:34;;;;;181365:1;181351:11;:15;181332:34;181328:761;;;181383:17;181403:54;181415:6;-1:-1:-1;;;;;181408:27:0;;:29;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;181408:29:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;181408:29:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;181408:29:0;181439:17;181403:4;:54::i;:::-;181383:74;;181472:16;181491:30;181496:11;181509;181491:4;:30::i;:::-;181472:49;;181536:19;;:::i;:::-;181573:1;181558:12;:16;:78;;181615:21;;;;;;;;181633:1;181615:21;;;181558:78;;;181577:35;181586:11;181599:12;181577:8;:35::i;:::-;181536:100;;181651:19;;:::i;:::-;181678:37;;;;;;;;;181696:17;;-1:-1:-1;;;;;181696:17:0;181678:37;;181673:50;;181717:5;181673:4;:50::i;:::-;181651:72;;181764:188;;;;;;;;181806:53;181814:5;:14;;;181806:53;;;;;;;;;;;;;;;;;:7;:53::i;:::-;-1:-1:-1;;;;;181764:188:0;;;;;181885:51;181892:11;181885:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;181885:51:0;;;:6;:51::i;:::-;181764:188;;;;;;;-1:-1:-1;;;;;181738:23:0;;;;;;:15;:23;;;;;;;;:214;;;;;;;;;;;;-1:-1:-1;;;181738:214:0;-1:-1:-1;;;;;181738:214:0;;;-1:-1:-1;;;;;;181738:214:0;;;;;;;;;;;;;;-1:-1:-1;181328:761:0;;-1:-1:-1;;;181328:761:0;;181974:15;;181970:119;;182026:51;182033:11;182026:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;182026:51:0;;;:6;:51::i;:::-;182006:71;;;;;;;-1:-1:-1;;;182006:71:0;-1:-1:-1;;;;;182006:71:0;;;;;;180993:1103;;;;;;:::o;183761:1054::-;-1:-1:-1;;;;;183935:23:0;;183897:35;183935:23;;;:15;:23;;;;;183969:25;;:::i;:::-;-1:-1:-1;183997:37:0;;;;;;;;;184015:17;;-1:-1:-1;;;;;184015:17:0;183997:37;;184045:27;;:::i;:::-;-1:-1:-1;184075:55:0;;;;;;;;;-1:-1:-1;;;;;184093:25:0;;;-1:-1:-1;184093:25:0;;;:17;:25;;;;;:35;;;;;;;;;;;;;;184075:55;;184179:20;;184141:35;;;;;;:58;;;;184216:22;;:26;184212:596;;184259:24;;:::i;:::-;184286:32;184291:11;184304:13;184286:4;:32::i;:::-;184259:59;;184333:19;184355:69;184367:6;-1:-1:-1;;;;;184360:34:0;;184395:8;184360:44;;;;;;;;;;;;;-1:-1:-1;;;;;184360:44:0;-1:-1:-1;;;;;184360:44:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;184360:44:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;184360:44:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;184360:44:0;184406:17;184355:4;:69::i;:::-;184333:91;;184439:18;184460:32;184465:14;184481:10;184460:4;:32::i;:::-;-1:-1:-1;;;;;184535:21:0;;184507:20;184535:21;;;:11;:21;;;;;;184439:53;;-1:-1:-1;184507:20:0;184530:42;;184439:53;184530:4;:42::i;:::-;184507:65;;184611:79;184624:8;184634:15;184651:13;:38;;134805:8;184651:38;;;184667:1;184651:38;184611:12;:79::i;:::-;-1:-1:-1;;;;;184587:21:0;;;;;;;:11;:21;;;;;;;;;:103;;;;184775:20;;184710:86;;;;;;;;;;;184587:21;;184710:86;;;;;;;;;;;;;;;184212:596;;;;;183761:1054;;;;;;;:::o;16132:153::-;16193:4;16215:33;16228:3;16223:9;;;;;;;;16239:4;16234:10;;;;;;;;16215:33;;;;;;;;;;;;;16246:1;16215:33;;;;;;;;;;;;;16273:3;16268:9;;;;;;;32379:149;32506:14;32489:13;;:31;;;32379:149::o;32166:141::-;32285:14;32269:13;;:30;;32166:141::o;178302:1326::-;178359:27;178389:10;178359:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;178359:40:0;;;;;;;;;;;;;;;;-1:-1:-1;178359:40:0;;-1:-1:-1;178417:6:0;;-1:-1:-1;;;;178412:299:0;178433:11;:18;178429:1;:22;178412:299;;;178473:13;178489:11;178501:1;178489:14;;;;;;;;;;;;;;178473:30;;178518:22;;:::i;:::-;178543:37;;;;;;;;178558:6;-1:-1:-1;;;;;178558:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;178558:20:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;178558:20:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;178558:20:0;178543:37;;178518:62;-1:-1:-1;178595:38:0;178625:6;178595:21;:38::i;:::-;178648:51;178678:6;178687:11;178648:21;:51::i;:::-;-1:-1:-1;;178453:3:0;;178412:299;;;;178723:23;;:::i;:::-;178749:18;;;;;;;;178764:1;178749:18;;;178723:44;;178778:22;178813:11;:18;178803:29;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;178778:54:0;-1:-1:-1;178848:6:0;178843:446;178864:11;:18;178860:1;:22;178843:446;;;178904:13;178920:11;178932:1;178920:14;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;178953:24:0;;;;;;:7;:24;;;;;;;:33;;;178920:14;;-1:-1:-1;178953:33:0;;178949:329;;;179007:21;;:::i;:::-;179031:50;;;;;;;;;;179046:6;;-1:-1:-1;;;179046:33:0;;;-1:-1:-1;;;;;179046:33:0;;;;;;;;;179031:50;;;;179046:6;;;:25;;:33;;;;;179031:50;179046:33;;;;;;:6;:33;;;5:2:-1;;;;30:1;27;20:12;5:2;179046:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;179046:33:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;179046:33:0;179031:50;;179007:74;-1:-1:-1;179100:18:0;;:::i;:::-;179121:39;179126:10;179138:6;-1:-1:-1;;;;;179138:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;179138:21:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;179138:21:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;179138:21:0;179121:4;:39::i;:::-;179100:60;;179194:7;179179:9;179189:1;179179:12;;;;;;;;;;;;;:22;;;;179235:27;179240:12;179254:7;179235:4;:27::i;:::-;179220:42;;178949:329;;;-1:-1:-1;178884:3:0;;178843:446;;;-1:-1:-1;179306:6:0;179301:320;179322:11;:18;179318:1;:22;179301:320;;;179362:13;179378:10;179389:1;179378:13;;;;;;;;;;;;;;;;;179422:21;;-1:-1:-1;;;;;179378:13:0;;;;-1:-1:-1;179422:80:0;;179501:1;179422:80;;;179450:48;179455:8;;179465:32;179470:9;179480:1;179470:12;;;;;;;;;;;;;;179484;179465:4;:32::i;:::-;179450:4;:48::i;:::-;-1:-1:-1;;;;;179517:27:0;;;;;;:10;:27;;;;;;;;;:38;;;179575:34;;;;;;;179406:96;;-1:-1:-1;179517:27:0;;179575:34;;;;;;;;;;;-1:-1:-1;;179342:3:0;;179301:320;;160767:3583;160952:5;160959:4;160965;160984:37;;:::i;:::-;-1:-1:-1;;;;;161186:22:0;;161069:9;161186:22;;;:13;:22;;;;;;;;161161:47;;;;;;;;;;;;;;;;;161069:9;;161161:22;;:47;161186:22;161161:47;;;161186:22;161161:47;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;161161:47:0;;;;;;;;;;;;;;;;-1:-1:-1;161161:47:0;;-1:-1:-1;161224:6:0;;-1:-1:-1;;;;161219:2780:0;161240:6;:13;161236:1;:17;161219:2780;;;161275:12;161290:6;161297:1;161290:9;;;;;;;;;;;;;;161275:24;;161460:5;-1:-1:-1;;;;;161460:24:0;;161485:7;161460:33;;;;;;;;;;;;;-1:-1:-1;;;;;161460:33:0;-1:-1:-1;;;;;161460:33:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;161460:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;161460:33:0;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;161460:33:0;;;;;;;;;;;;;;;;;161431:25;;161384:109;161411:18;;;161384:109;;;;161391:18;;;161384:109;;;;161460:33;-1:-1:-1;161512:9:0;;161508:166;;-1:-1:-1;161631:20:0;;-1:-1:-1;161653:1:0;;-1:-1:-1;161653:1:0;;-1:-1:-1;161623:35:0;;-1:-1:-1;;;;;161623:35:0;161508:166;161712:65;;;;;;;;;-1:-1:-1;;;;;161727:23:0;;;-1:-1:-1;161727:23:0;;;:7;:23;;;;;:48;;;161712:65;;161688:21;;;:89;;;;161812:42;;;;;;;-1:-1:-1;;;161827:25:0;161812:42;;161792:17;;;:62;161952:6;;;:32;;-1:-1:-1;;;161952:32:0;;;;;;;;;;;:6;;;:25;;:32;;;;;161712:65;161952:32;;;;;:6;:32;;;5:2:-1;;;;30:1;27;20:12;5:2;161952:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;161952:32:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;161952:32:0;161925:24;;;:59;;;161999:102;;-1:-1:-1;162061:17:0;;-1:-1:-1;162080:1:0;;-1:-1:-1;162080:1:0;;-1:-1:-1;162053:32:0;;-1:-1:-1;;;;;162053:32:0;161999:102;162134:41;;;;;;;;;162149:24;;;;162134:41;;162115:16;;;:60;;;162323:21;;;;162346:17;;;;162315:67;;:7;:67::i;:::-;162293:18;;;162286:96;;-1:-1:-1;162409:18:0;162401:4;:26;;;;;;;;;162397:98;;-1:-1:-1;162456:16:0;;-1:-1:-1;162474:1:0;;-1:-1:-1;162474:1:0;;-1:-1:-1;162448:31:0;;-1:-1:-1;;;;;162448:31:0;162397:98;162603:84;162628:4;:18;;;162648:4;:18;;;162668:4;:18;;;162603:24;:84::i;:::-;162574:113;;;-1:-1:-1;162581:18:0;162706:4;:26;;;;;;;;;162702:98;;-1:-1:-1;162761:16:0;;-1:-1:-1;162779:1:0;;-1:-1:-1;162779:1:0;;-1:-1:-1;162753:31:0;;-1:-1:-1;;;;;162753:31:0;162702:98;162920:89;162945:4;:16;;;162963:4;:18;;;162983:4;:25;;;162920:24;:89::i;:::-;162891:25;;;162884:125;;-1:-1:-1;163036:18:0;163028:4;:26;;;;;;;;;163024:98;;-1:-1:-1;163083:16:0;;-1:-1:-1;163101:1:0;;-1:-1:-1;163101:1:0;;-1:-1:-1;163075:31:0;;-1:-1:-1;;;;;163075:31:0;163024:98;163218:12;-1:-1:-1;;;;;163209:21:0;:5;-1:-1:-1;;;;;163209:21:0;;163205:783;;;163394:85;163419:4;:18;;;163439:12;163453:4;:25;;;163394:24;:85::i;:::-;163365:25;;;163358:121;;-1:-1:-1;163510:18:0;163502:4;:26;;;;;;;;;163498:106;;-1:-1:-1;163561:16:0;;-1:-1:-1;163579:1:0;;-1:-1:-1;163579:1:0;;-1:-1:-1;163553:31:0;;-1:-1:-1;;;;;163553:31:0;163498:106;163765:83;163790:4;:16;;;163808:12;163822:4;:25;;;163765:24;:83::i;:::-;163736:25;;;163729:119;;-1:-1:-1;163879:18:0;163871:4;:26;;;;;;;;;163867:106;;-1:-1:-1;163930:16:0;;-1:-1:-1;163948:1:0;;-1:-1:-1;163948:1:0;;-1:-1:-1;163922:31:0;;-1:-1:-1;;;;;163922:31:0;163867:106;-1:-1:-1;161255:3:0;;161219:2780;;;-1:-1:-1;164108:25:0;;;;164087:18;;:46;164083:260;;;-1:-1:-1;;;164195:25:0;;;;164174:18;;164158:14;;-1:-1:-1;164174:46:0;;-1:-1:-1;164158:14:0;;-1:-1:-1;164150:74:0;;164083:260;-1:-1:-1;;164312:18:0;;164284:25;;;;;164265:14;;-1:-1:-1;164265:14:0;;-1:-1:-1;164284:46:0;;;;;-1:-1:-1;164257:74:0;;-1:-1:-1;164257:74:0;179787:1047;-1:-1:-1;;;;;179892:23:0;;179854:35;179892:23;;;:15;:23;;;;;;;;179945:10;:18;;;;;;179892:23;;179993:16;:14;:16::i;:::-;180062:17;;179974:35;;-1:-1:-1;180020:16:0;;180039:42;;179974:35;;-1:-1:-1;;;180062:17:0;;;;180039:4;:42::i;:::-;180020:61;;180110:1;180096:11;:15;:34;;;;;180129:1;180115:11;:15;180096:34;180092:735;;;180147:17;180174:6;-1:-1:-1;;;;;180167:26:0;;:28;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;180167:28:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;180167:28:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;180167:28:0;;-1:-1:-1;180210:16:0;180229:30;180234:11;180247;180229:4;:30::i;:::-;180210:49;;180274:19;;:::i;:::-;180311:1;180296:12;:16;:78;;180353:21;;;;;;;;180371:1;180353:21;;;180296:78;;;180315:35;180324:11;180337:12;180315:8;:35::i;:::-;180274:100;;180389:19;;:::i;:::-;180416:37;;;;;;;;;180434:17;;-1:-1:-1;;;;;180434:17:0;180416:37;;180411:50;;180455:5;180411:4;:50::i;:::-;180389:72;;180502:188;;;;;;;;180544:53;180552:5;:14;;;180544:53;;;;;;;;;;;;;;;;;:7;:53::i;:::-;-1:-1:-1;;;;;180502:188:0;;;;;180623:51;180630:11;180623:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;180623:51:0;;;:6;:51::i;:::-;180502:188;;;;;;;-1:-1:-1;;;;;180476:23:0;;;;;;:15;:23;;;;;;;;:214;;;;;;;;;;;;-1:-1:-1;;;180476:214:0;-1:-1:-1;;;;;180476:214:0;;;-1:-1:-1;;;;;;180476:214:0;;;;;;;;;;;;;;-1:-1:-1;180092:735:0;;-1:-1:-1;;;180092:735:0;;180712:15;;180708:119;;180764:51;180771:11;180764:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;180764:51:0;;;:6;:51::i;:::-;180744:71;;;;;;;-1:-1:-1;;;180744:71:0;-1:-1:-1;;;;;180744:71:0;;;;;;179787:1047;;;;;:::o;182352:1052::-;-1:-1:-1;;;;;182496:23:0;;182458:35;182496:23;;;:15;:23;;;;;182530:25;;:::i;:::-;-1:-1:-1;182558:37:0;;;;;;;;;182576:17;;-1:-1:-1;;;;;182576:17:0;182558:37;;182606:27;;:::i;:::-;-1:-1:-1;182636:55:0;;;;;;;;;-1:-1:-1;;;;;182654:25:0;;;-1:-1:-1;182654:25:0;;;:17;:25;;;;;:35;;;;;;;;;;;;;;182636:55;;182740:20;;182702:35;;;;;;:58;;;;182777:22;;:27;:55;;;;-1:-1:-1;182808:20:0;;:24;;182777:55;182773:129;;;134918:4;182849:41;;182773:129;182914:24;;:::i;:::-;182941:32;182946:11;182959:13;182941:4;:32::i;:::-;182914:59;;182984:19;183013:6;-1:-1:-1;;;;;183006:24:0;;183031:8;183006:34;;;;;;;;;;;;;-1:-1:-1;;;;;183006:34:0;-1:-1:-1;;;;;183006:34:0;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;183006:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;183006:34:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;183006:34:0;;-1:-1:-1;183051:18:0;183072:32;183006:34;183093:10;183072:4;:32::i;:::-;-1:-1:-1;;;;;183143:21:0;;183115:20;183143:21;;;:11;:21;;;;;;183051:53;;-1:-1:-1;183115:20:0;183138:42;;183051:53;183138:4;:42::i;:::-;183115:65;;183215:79;183228:8;183238:15;183255:13;:38;;134805:8;183255:38;;183215:79;-1:-1:-1;;;;;183191:21:0;;;;;;;:11;:21;;;;;;;;;:103;;;;183375:20;;183310:86;;;;;;;;;;;183191:21;;183310:86;;;;;;;;;;;;;;;182352:1052;;;;;;;;;;:::o;158756:187::-;158833:5;158840:4;158846;158870:65;158910:7;158926:1;158930;158933;158870:39;:65::i;:::-;158863:72;;;;;;158756:187;;;;;:::o;27056:313::-;27133:9;27144:4;27162:13;27177:18;;:::i;:::-;27199:20;27209:1;27212:6;27199:9;:20::i;:::-;27161:58;;-1:-1:-1;27161:58:0;-1:-1:-1;27241:18:0;27234:3;:25;;;;;;;;;27230:73;;-1:-1:-1;27284:3:0;-1:-1:-1;27289:1:0;;-1:-1:-1;27276:15:0;;27230:73;27323:18;27343:17;27352:7;27343:8;:17::i;:::-;27315:46;;;;;;27056:313;;;;;;:::o;177835:148::-;177889:4;177927:5;;-1:-1:-1;;;;;177927:5:0;177913:10;:19;;:62;;-1:-1:-1;177950:25:0;;-1:-1:-1;;;;;177950:25:0;177936:10;:39;177913:62;177906:69;;177835:148;:::o;174589:250::-;174658:6;174653:137;174674:10;:17;174670:21;;174653:137;;;174746:6;-1:-1:-1;;;;;174722:31:0;:10;174733:1;174722:13;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;174722:13:0;:31;;174714:64;;;;;-1:-1:-1;;;174714:64:0;;;;;;;;;;;;-1:-1:-1;;;174714:64:0;;;;;;;;;;;;;;;174693:4;;174653:137;;;-1:-1:-1;174800:10:0;27::-1;;39:1;23:18;;45:23;;-1:-1;174800:31:0;;;;;;;;-1:-1:-1;;;;;;174800:31:0;-1:-1:-1;;;;;174800:31:0;;;;;;;;;;174589:250::o;143921:871::-;-1:-1:-1;;;;;144050:15:0;;144028:4;144050:15;;;:7;:15;;;;;:24;;;144045:94;;144103:23;144098:29;;144045:94;-1:-1:-1;;;;;144250:15:0;;;;;;;:7;:15;;;;;;;;:43;;;;;:33;;;;:43;;;;;;144245:104;;144322:14;144317:20;;144245:104;144454:9;144467:14;144485:82;144525:8;144542:6;144551:12;144565:1;144485:39;:82::i;:::-;144453:114;;-1:-1:-1;144453:114:0;;-1:-1:-1;144589:14:0;;-1:-1:-1;144582:3:0;:21;;;;;;;;;144578:70;;144632:3;144627:9;;;;;;;144578:70;144662:13;;144658:87;;144704:28;144699:34;;137491:1173;-1:-1:-1;;;;;137619:24:0;;137571:5;137619:24;;;:7;:24;;;;;137661:21;;;;137656:135;;137756:23;137749:30;;;;;137656:135;-1:-1:-1;;;;;137807:40:0;;;;;;:30;;;:40;;;;;;;;:48;;:40;:48;137803:133;;;137910:14;137903:21;;;;;137803:133;137986:9;;-1:-1:-1;;;;;137952:23:0;;;;;;:13;:23;;;;;:30;:43;137948:143;;138058:21;138051:28;;;;;137948:143;-1:-1:-1;;;;;138479:40:0;;;;;;;:30;;;:40;;;;;;;;:47;;-1:-1:-1;;138479:47:0;138522:4;138479:47;;;;;;138537:13;:23;;;;;27:10:-1;;23:18;;;45:23;;138537:36:0;;;;;;;;;;;;;;-1:-1:-1;;;;;;138537:36:0;;;;;;;138591:31;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;138642:14:0;;137491:1173;-1:-1:-1;;;137491:1173:0:o;30793:150::-;30848:9;30859:10;;:::i;:::-;30889:46;30896:18;;;;;;;;30911:1;30896:18;;;30916;;;;;;;;30931:1;30916:18;;;30889:6;:46::i;:::-;30882:53;;;;30793:150;;;;;:::o;31565:146::-;31632:9;31643:10;;:::i;:::-;31680;;31692;;31673:30;;31680:10;31673:6;:30::i;188609:943::-;-1:-1:-1;;;;;188701:15:0;;188677:21;188701:15;;;:7;:15;;;;;188735;;;;:23;;:15;:23;188727:61;;;;;-1:-1:-1;;;188727:61:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;188807:15;;;;;;:24;188799:62;;;;;-1:-1:-1;;;188799:62:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;188874:15;;;:22;;-1:-1:-1;;188874:22:0;188892:4;188874:22;;;;;;188912:34;;;-1:-1:-1;;;;;188912:34:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;188963:23:0;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;;;188963:29:0;:34;:72;;;;-1:-1:-1;;;;;;189001:23:0;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;189001:29:0;;;;:34;188963:72;188959:287;;;189078:156;;;;;;;;134918:4;-1:-1:-1;;;;;189078:156:0;;;;;189162:56;189169:16;:14;:16::i;:::-;189162:56;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;189162:56:0;;;:6;:56::i;:::-;189078:156;;;;;;;-1:-1:-1;;;;;189052:23:0;;;;;;:15;:23;;;;;;;;:182;;;;;;;;;;;;-1:-1:-1;;;189052:182:0;-1:-1:-1;;;;;189052:182:0;;;-1:-1:-1;;;;;;189052:182:0;;;;;;;;;;;;;;188959:287;-1:-1:-1;;;;;189262:23:0;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;;;189262:29:0;:34;:72;;;;-1:-1:-1;;;;;;189300:23:0;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;189300:29:0;;;;:34;189262:72;189258:287;;;189377:156;;;;;;;;134918:4;-1:-1:-1;;;;;189377:156:0;;;;;189461:56;189468:16;:14;:16::i;189461:56::-;189377:156;;;;;;;-1:-1:-1;;;;;189351:23:0;;;;;;:15;:23;;;;;;;;:182;;;;;;;;;;;;-1:-1:-1;;;189351:182:0;-1:-1:-1;;;;;189351:182:0;;;-1:-1:-1;;;;;;189351:182:0;;;;;;;;;;;;;;188609:943;;:::o;16408:187::-;16493:4;16515:43;16528:3;16523:9;;;;;;;;16539:4;16534:10;;;;;;;;16515:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;16583:3;16578:9;;;;;;;34238:120;34291:4;34315:35;34320:1;34323;34315:35;;;;;;;;;;;;;-1:-1:-1;;;34315:35:0;;;:4;:35::i;36137:126::-;36196:4;36220:35;36225:17;36230:1;24902:4;36225;:17::i;:::-;36244:10;;36220:4;:35::i;35436:122::-;35489:4;35513:37;35518:1;35521;35513:37;;;;;;;;;;;;;;;;;:4;:37::i;37034:147::-;37091:13;;:::i;:::-;37124:49;;;;;;;;37142:29;37147:20;37152:1;24941:4;37147;:20::i;:::-;37169:1;37142:4;:29::i;:::-;37124:49;;37117:56;37034:147;-1:-1:-1;;;37034:147:0:o;33435:160::-;33506:13;;:::i;:::-;33539:48;;;;;;;;33557:28;33562:1;:10;;;33574:1;:10;;;33557:4;:28::i;32937:165::-;33013:7;33053:12;-1:-1:-1;;;33041:10:0;;33033:33;;;;-1:-1:-1;;;33033:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;33033:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33092:1:0;;32937:165;-1:-1:-1;;32937:165:0:o;33110:161::-;33185:6;33223:12;-1:-1:-1;;;33212:9:0;;33204:32;;;;-1:-1:-1;;;33204:32:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;34070:160:0;34141:13;;:::i;:::-;34174:48;;;;;;;;34192:28;34197:1;:10;;;34209:1;:10;;;34192:4;:28::i;35301:127::-;35363:4;24941;35387:19;35392:1;35395;:10;;;35387:4;:19::i;:::-;:33;;;;;;;35301:127;-1:-1:-1;;;35301:127:0:o;33603:116::-;33656:4;33680:31;33685:1;33688;33680:31;;;;;;;;;;;;;-1:-1:-1;;;33680:31:0;;;:4;:31::i;185206:482::-;-1:-1:-1;185669:11:0;185206:482;-1:-1:-1;185206:482:0:o;34699:133::-;34758:10;;:::i;:::-;34788:36;;;;;;;;34803:19;34808:1;:10;;;34820:1;34803:4;:19::i;35824:164::-;35889:10;;:::i;:::-;35919:61;;;;;;;;35934:44;35939:26;35944:1;:10;;;24902:4;35939;:26::i;:::-;35967:10;;35934:4;:44::i;34840:121::-;34899:4;24902;34923:19;34928:1;34931;:10;;;34923:4;:19::i;31042:284::-;31124:9;31135:10;;:::i;:::-;31159:13;31174;;:::i;:::-;31191:12;31198:1;31201;31191:6;:12::i;:::-;31158:45;;-1:-1:-1;31158:45:0;-1:-1:-1;31225:18:0;31218:3;:25;;;;;;;;;31214:74;;31268:3;;-1:-1:-1;31273:2:0;-1:-1:-1;31260:16:0;;31214:74;31305:13;31312:2;31316:1;31305:6;:13::i;:::-;31298:20;;;;;;31042:284;;;;;;:::o;27514:328::-;27611:9;27622:4;27640:13;27655:18;;:::i;:::-;27677:20;27687:1;27690:6;27677:9;:20::i;:::-;27639:58;;-1:-1:-1;27639:58:0;-1:-1:-1;27719:18:0;27712:3;:25;;;;;;;;;27708:73;;-1:-1:-1;27762:3:0;-1:-1:-1;27767:1:0;;-1:-1:-1;27754:15:0;;27708:73;27800:34;27808:17;27817:7;27808:8;:17::i;:::-;27827:6;27800:7;:34::i;26590:353::-;26659:9;26670:10;;:::i;:::-;26694:14;26710:19;26733:27;26741:1;:10;;;26753:6;26733:7;:27::i;:::-;26693:67;;-1:-1:-1;26693:67:0;-1:-1:-1;26783:18:0;26775:4;:26;;;;;;;;;26771:92;;-1:-1:-1;26832:18:0;;;;;;;;;-1:-1:-1;26832:18:0;;26826:4;;-1:-1:-1;26832:18:0;-1:-1:-1;26818:33:0;;26771:92;26903:31;;;;;;;;;;;;-1:-1:-1;;26903:31:0;;-1:-1:-1;26590:353:0;-1:-1:-1;;;;26590:353:0:o;31869:213::-;32051:12;24902:4;32051:23;;;31869:213::o;29538:1136::-;29605:9;29616:10;;:::i;:::-;29642:14;29658:24;29686:31;29694:1;:10;;;29706:1;:10;;;29686:7;:31::i;:::-;29641:76;;-1:-1:-1;29641:76:0;-1:-1:-1;29740:18:0;29732:4;:26;;;;;;;;;29728:92;;-1:-1:-1;29789:18:0;;;;;;;;;-1:-1:-1;29789:18:0;;29783:4;;-1:-1:-1;29789:18:0;-1:-1:-1;29775:33:0;;29728:92;30137:14;;30194:42;24981:10;30216:19;30194:7;:42::i;:::-;30136:100;;-1:-1:-1;30136:100:0;-1:-1:-1;30259:18:0;30251:4;:26;;;;;;;;;30247:92;;-1:-1:-1;30308:18:0;;;;;;;;;-1:-1:-1;30308:18:0;;30302:4;;-1:-1:-1;30308:18:0;-1:-1:-1;30294:33:0;;-1:-1:-1;;30294:33:0;30247:92;30352:14;30368:12;30384:51;30392:32;24902:4;30384:7;:51::i;:::-;30351:84;;-1:-1:-1;30351:84:0;-1:-1:-1;30581:18:0;30573:4;:26;;;;;;;;;30566:34;;;;30641:24;;;;;;;;;;;;-1:-1:-1;;30641:24:0;;-1:-1:-1;29538:1136:0;-1:-1:-1;;;;;;;;29538:1136:0:o;25349:515::-;25410:9;25421:10;;:::i;:::-;25445:14;25461:20;25485:22;25493:3;24902:4;25485:7;:22::i;:::-;25444:63;;-1:-1:-1;25444:63:0;-1:-1:-1;25530:18:0;25522:4;:26;;;;;;;;;25518:92;;-1:-1:-1;25579:18:0;;;;;;;;;-1:-1:-1;25579:18:0;;25573:4;;-1:-1:-1;25579:18:0;-1:-1:-1;25565:33:0;;25518:92;25623:14;25639:13;25656:31;25664:15;25681:5;25656:7;:31::i;:::-;25622:65;;-1:-1:-1;25622:65:0;-1:-1:-1;25710:18:0;25702:4;:26;;;;;;;;;25698:92;;-1:-1:-1;25759:18:0;;;;;;;;;-1:-1:-1;25759:18:0;;25753:4;;-1:-1:-1;25759:18:0;-1:-1:-1;25745:33:0;;-1:-1:-1;;25745:33:0;25698:92;25830:25;;;;;;;;;;;;-1:-1:-1;;25830:25:0;;-1:-1:-1;25349:515:0;-1:-1:-1;;;;;;25349:515:0:o;34366:158::-;34447:4;34480:12;34472:6;;;;34464:29;;;;-1:-1:-1;;;34464:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;34464:29:0;-1:-1:-1;;;34511:5:0;;;34366:158::o;36748:113::-;36801:4;36825:28;36830:1;36833;36825:28;;;;;;;;;;;;;-1:-1:-1;;;36825:28:0;;;:4;:28::i;35566:250::-;35647:4;35668:6;;;:16;;-1:-1:-1;35678:6:0;;35668:16;35664:57;;;-1:-1:-1;35708:1:0;35701:8;;35664:57;35740:5;;;35744:1;35740;:5;:1;35764:5;;;;;:10;35776:12;35756:33;;;;;-1:-1:-1;;;35756:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;35756:33:0;-1:-1:-1;35807:1:0;35566:250;-1:-1:-1;;;;35566:250:0:o;33727:179::-;33808:4;33834:5;;;33866:12;33858:6;;;;33850:29;;;;-1:-1:-1;;;33850:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;23829:258:0;23885:9;;23922:5;;;23944:6;;;23940:140;;23975:18;;-1:-1:-1;23995:1:0;-1:-1:-1;23967:30:0;;23940:140;-1:-1:-1;24038:26:0;;-1:-1:-1;24066:1:0;;-1:-1:-1;24030:38:0;;22720:343;22776:9;;22808:6;22804:69;;-1:-1:-1;22839:18:0;;-1:-1:-1;22839:18:0;22831:30;;22804:69;22894:5;;;22898:1;22894;:5;:1;22916:5;;;;;:10;22912:144;;-1:-1:-1;22951:26:0;;-1:-1:-1;22979:1:0;;-1:-1:-1;22943:38:0;;22912:144;23022:18;;-1:-1:-1;23042:1:0;-1:-1:-1;23014:30:0;;23158:215;23214:9;;23246:6;23242:77;;-1:-1:-1;23277:26:0;;-1:-1:-1;23305:1:0;23269:38;;23242:77;23339:18;23363:1;23359;:5;;;;;;23331:34;;;;23158:215;;;;;:::o;36869:157::-;36950:4;36982:12;36975:5;36967:28;;;;-1:-1:-1;;;36967:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;36967:28:0;;37017:1;37013;:5;;;;;;;36869:157;-1:-1:-1;;;;36869:157:0:o;132307:58439::-;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;
Swarm Source
bzzr://31df1e77f2266eaead8b6cf006d57c112622229fe5bbf12532d21e650a058419
Loading...
Loading
Loading...
Loading
Multichain Portfolio | 26 Chains
Chain | Token | Portfolio % | Price | Amount | Value |
---|
Loading...
Loading
[ Download: CSV Export ]
A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.