Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity ^0.5.16;

import "./CToken.sol";
import "./ErrorReporter.sol";
import "./Exponential.sol";
import "./PriceOracle.sol";
import "./ComptrollerInterface.sol";
import "./ComptrollerStorage.sol";
import "./Unitroller.sol";
import "./Governance/Comp.sol";

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

pragma solidity ^0.5.16;

import "./ComptrollerInterface.sol";
import "./CTokenInterfaces.sol";
import "./ErrorReporter.sol";
import "./Exponential.sol";
import "./EIP20Interface.sol";
import "./EIP20NonStandardInterface.sol";
import "./InterestRateModel.sol";

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

pragma solidity ^0.5.16;

import "./ComptrollerInterface.sol";
import "./InterestRateModel.sol";

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;
}

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);
    }
}

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);
}

pragma solidity ^0.5.16;

import "./CToken.sol";
import "./PriceOracle.sol";

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;
}

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);
}

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);
}

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);
    }
}

pragma solidity ^0.5.16;

import "./CarefulMath.sol";

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

pragma solidity ^0.5.16;
pragma experimental ABIEncoderV2;

contract Comp {
    /// @notice EIP-20 token name for this token
    string public constant name = "Compound";

    /// @notice EIP-20 token symbol for this token
    string public constant symbol = "COMP";

    /// @notice EIP-20 token decimals for this token
    uint8 public constant decimals = 18;

    /// @notice Total number of tokens in circulation
    uint public constant totalSupply = 10000000e18; // 10 million Comp

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

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);

}

pragma solidity ^0.5.16;

import "./CToken.sol";

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);
}

pragma solidity ^0.5.16;

import "./ErrorReporter.sol";
import "./ComptrollerStorage.sol";
/**
 * @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) }
        }
    }
}

{
  "evmVersion": "istanbul",
  "libraries": {},
  "metadata": {
    "useLiteralContent": true
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "remappings": [],
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• 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"}]

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

337:57050:3:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;337:57050:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;141:41:4;;;:::i;:::-;;;;;;;;;;;;;;;;;;43193:501:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;43193:501:3;;;;;;;;;;:::i;52910:205::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;52910:205:3;;;;;;;;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;52910:205:3;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;52910:205:3;;;;;;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;52910:205:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;52910:205:3;;-1:-1:-1;52910:205:3;;-1:-1:-1;;;;;52910:205:3:i;:::-;;44445:231;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44445:231:3;-1:-1:-1;;;;;44445:231:3;;:::i;3265:42:5:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3265:42:5;-1:-1:-1;;;;;3265:42:5;;:::i;:::-;;;;;;;;;;;;;;;;17283:441:3;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;17283:441:3;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;16344:626::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;16344:626:3;;;;;;;;;;;;;;;;;;;;;;:::i;2426:28:5:-;;;:::i;:::-;;;;-1:-1:-1;;;;;2426:28:5;;;;;;;;;;;;;;273:27;;;:::i;44077:362:3:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44077:362:3;;;;:::i;35193:1029::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;35193:1029:3;;:::i;56405:373::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;56405:373:3;-1:-1:-1;;;;;56405:373:3;;:::i;42692:495::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;42692:495:3;;;;;;;;;;:::i;2460:31:5:-;;;:::i;10432:351:3:-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;10432:351:3;;;;;;;;;;;;;;;;;;;;;;:::i;57065:89::-;;;:::i;19892:527::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;19892:527:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;952:40:5:-;;;:::i;45061:175:3:-;;;:::i;26934:401::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;26934:401:3;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;9523:586;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;9523:586:3;;;;;;;;;;;;;;;;;:::i;39163:1476::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;39163:1476:3;;:::i;12856:340::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;12856:340:3;;;;;;;;;;;;;;;;;;;;;;:::i;3054:26:5:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3054:26:5;;:::i;34344:556:3:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;34344:556:3;-1:-1:-1;;;;;34344:556:3;;:::i;15545:312::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;15545:312:3;;;;;;;;;;;;;;;;;:::i;25581:264::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;25581:264:3;-1:-1:-1;;;;;25581:264:3;;:::i;42094:592::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;42094:592:3;-1:-1:-1;;;;;42094:592:3;;:::i;18168:1260::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;18168:1260:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;53449:933::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;53449:933:3;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;53449:933:3;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;53449:933:3;;;;;;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;53449:933:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;53449:933:3;;;;;;;;-1:-1:-1;53449:933:3;;-1:-1:-1;;;;;5:28;;2:2;;;46:1;43;36:12;2:2;53449:933:3;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;53449:933:3;;;;;;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;53449:933:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;53449:933:3;;-1:-1:-1;;;;53449:933:3;;;;;-1:-1:-1;53449:933:3;;;;;;:::i;54574:275::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;54574:275:3;;:::i;24275:334::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;24275:334:3;;;;;;;;;;;;;;;;;;;;;;:::i;3375:58:5:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3375:58:5;-1:-1:-1;;;;;3375:58:5;;:::i;:::-;;;;-1:-1:-1;;;;;3375:58:5;;;;;;;;;;;;;;;;;;;;;;2669:52;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2669:52:5;-1:-1:-1;;;;;2669:52:5;;:::i;22283:458:3:-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;22283:458:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;2613:50:5:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2613:50:5;-1:-1:-1;;;;;2613:50:5;;:::i;2743::3:-;;;:::i;663:25:5:-;;;:::i;2536:34::-;;;:::i;3501:58::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3501:58:5;-1:-1:-1;;;;;3501:58:5;;:::i;2114:41::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;2114:41:5;-1:-1:-1;;;;;2114:41:5;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43700:371:3;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;43700:371:3;;;;:::i;4334:161::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;4334:161:3;;;;;;;;;;:::i;1117:21:5:-;;;:::i;57263:122:3:-;;;:::i;40958:654::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;40958:654:3;-1:-1:-1;;;;;40958:654:3;;:::i;2852:47::-;;;:::i;:::-;;;;-1:-1:-1;;;;;2852:47:3;;;;;;;;;;;;;;3162:20:5;;;:::i;3895:170:3:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;3895:170:3;-1:-1:-1;;;;;3895:170:3;;:::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;3895:170:3;;;;;;;;;;;;;;;;;2576:31:5;;;:::i;56962:97:3:-;;;:::i;3676:69:5:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;3676:69:5;;;;;;;;;;:::i;364:40::-;;;:::i;23198:761:3:-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;23198:761:3;;;;;;;;;;;;;;;;;;;;;;:::i;4754:368::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;4754:368:3;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;4754:368:3;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;4754:368:3;;;;;;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;4754:368:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;4754:368:3;;-1:-1:-1;4754:368:3;;-1:-1:-1;;;;;4754:368:3:i;32139:1949::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;32139:1949:3;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;3862:69:5;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;3862:69:5;;;;;;;;;;:::i;4008:43::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4008:43:5;-1:-1:-1;;;;;4008:43:5;;:::i;55015:288:3:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;55015:288:3;;;;;;;;-1:-1:-1;;;5:28;;2:2;;;46:1;43;36:12;2:2;55015:288:3;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;55015:288:3;;;;;;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;55015:288:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;55015:288:3;;-1:-1:-1;55015:288:3;;-1:-1:-1;;;;;55015:288:3:i;20872:960::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;20872:960:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;38467:403::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;38467:403:3;;:::i;13628:1618::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;13628:1618:3;;;;;;;;;;;;;;;;;:::i;1240:49:5:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;1240:49:5;;;;;;;;:::i;469:47::-;;;:::i;36587:1606:3:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;36587:1606:3;;;;;;;;:::i;2497:33:5:-;;;:::i;805:31::-;;;:::i;52606:95:3:-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52606:95:3;-1:-1:-1;;;;;52606:95:3;;:::i;11225:441::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;11225:441:3;;;;;;;;;;;;;;;;;:::i;6928:2127::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;6928:2127:3;-1:-1:-1;;;;;6928:2127:3;;:::i;177:20:5:-;;;:::i;141:41:4:-;178:4;141:41;:::o;43193:501:3:-;-1:-1:-1;;;;;43286:24:3;;43262:4;43286:24;;;:7;:24;;;;;:33;;;43278:86;;;;-1:-1:-1;;;43278:86:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43396:13;;-1:-1:-1;;;;;43396:13:3;43382:10;:27;;:50;;-1:-1:-1;43427:5:3;;-1:-1:-1;;;;;43427:5:3;43413:10;:19;43382:50;43374:102;;;;-1:-1:-1;;;43374:102:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43508:5;;-1:-1:-1;;;;;43508:5:3;43494:10;:19;;:36;;-1:-1:-1;43526:4:3;43517:13;;;;43494:36;43486:71;;;;;-1:-1:-1;;;43486:71:3;;;;;;;;;;;;-1:-1:-1;;;43486:71:3;;;;;;;;;;;;;;;-1:-1:-1;;;;;43568:37:3;;;;;;:20;:37;;;;;;;;;:45;;;;;-1:-1:-1;;43568:45:3;;;;;;;;43628:37;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;43628:37:3;;;;;;;;;;;;;;-1:-1:-1;43682:5:3;43193:501;;;;;:::o;52910:205::-;53014:16;;;53028:1;53014:16;;;;;;;;;52987:24;;53014:16;;;;;;105:10:-1;53014:16:3;88:34:-1;136:17;;-1:-1;53014:16:3;52987:43;;53053:6;53040:7;53048:1;53040:10;;;;;;;;;;;;;:19;-1:-1:-1;;;;;53040:19:3;;;-1:-1:-1;;;;;53040:19:3;;;;;53069:39;53079:7;53088;53097:4;53103;53069:9;:39::i;:::-;52910:205;;;:::o;44445:231::-;44524:10;-1:-1:-1;;;;;44524:16:3;;:18;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44524:18:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44524:18:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44524:18:3;-1:-1:-1;;;;;44510:32:3;:10;:32;44502:84;;;;-1:-1:-1;;;44502:84:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44604:10;-1:-1:-1;;;;;44604:32:3;;:34;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;44604:34:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44604:34:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44604:34:3;:39;44596:73;;;;;-1:-1:-1;;;44596:73:3;;;;;;;;;;;;-1:-1:-1;;;44596:73:3;;;;;;;;;;;;;;;44445:231;:::o;3265:42:5:-;;;;;;;;;;;;;:::o;17283:441:3:-;;;;;;:::o;16344:626::-;-1:-1:-1;;;;;16600:15:3;;16490:4;16600:15;;;:7;:15;;;;;:24;;;16595:92;;-1:-1:-1;16652:23:3;16640:36;;16595:92;16733:22;;:::i;:::-;16758:45;;;;;;;;16780:6;-1:-1:-1;;;;;16773:26:3;;:28;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;16773:28:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;16773:28:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;16773:28:3;16758:45;;16733:70;-1:-1:-1;16813:42:3;16835:6;16733:70;16813:21;:42::i;:::-;16865:60;16888:6;16896:8;16906:11;16919:5;16865:22;:60::i;:::-;16948:14;16936:27;;;16344:626;;;;;;;:::o;2426:28:5:-;;;-1:-1:-1;;;;;2426:28:5;;:::o;273:27::-;;;-1:-1:-1;;;;;273:27:5;;:::o;44077:362:3:-;44168:13;;44130:4;;-1:-1:-1;;;;;44168:13:3;44154:10;:27;;:50;;-1:-1:-1;44199:5:3;;-1:-1:-1;;;;;44199:5:3;44185:10;:19;44154:50;44146:102;;;;-1:-1:-1;;;44146:102:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44280:5;;-1:-1:-1;;;;;44280:5:3;44266:10;:19;;:36;;-1:-1:-1;44298:4:3;44289:13;;;;44266:36;44258:71;;;;;-1:-1:-1;;;44258:71:3;;;;;;;;;;;;-1:-1:-1;;;44258:71:3;;;;;;;;;;;;;;;44340:19;:27;;;;;-1:-1:-1;;;44340:27:3;;-1:-1:-1;;;;44340:27:3;;;;;;;;;;44382:28;;;;;;;;;;;;;;;;;;-1:-1:-1;;;44382:28:3;;;;;;;;;;;;;;-1:-1:-1;44427:5:3;44077:362;;;;:::o;35193:1029::-;35265:4;35332:5;;-1:-1:-1;;;;;35332:5:3;35318:10;:19;35314:123;;35360:66;35365:18;35385:40;35360:4;:66::i;:::-;35353:73;;;;35314:123;35447:28;;:::i;:::-;-1:-1:-1;35478:39:3;;;;;;;;;;;;35527:19;;:::i;:::-;-1:-1:-1;35549:39:3;;;;;;;;;3022:7;35549:39;;35602:47;35621:17;35549:39;35602:18;:47::i;:::-;35598:158;;;35672:73;35677:26;35705:39;35672:4;:73::i;:::-;35665:80;;;;;;35598:158;35766:20;;:::i;:::-;-1:-1:-1;35789:39:3;;;;;;;;;3146:6;35789:39;;35842:41;35789:39;35865:17;35842:11;:41::i;:::-;35838:152;;;35906:73;35911:26;35939:39;35906:4;:73::i;:::-;35899:80;;;;;;;35838:152;36030:19;;;36059:44;;;;36118:59;;;;;;;;;;;;;;;;;;;;;;;;;36200:14;36195:20;36188:27;35193:1029;-1:-1:-1;;;;;;35193:1029:3:o;56405:373::-;56485:5;;-1:-1:-1;;;;;56485:5:3;56471:10;:19;56463:63;;;;;-1:-1:-1;;;56463:63:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56561:15:3;;56537:21;56561:15;;;:7;:15;;;;;56594;;;;;;:23;;:15;:23;56586:63;;;;;-1:-1:-1;;;56586:63:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;56660:15;;;:23;;-1:-1:-1;;56660:23:3;;;56698:35;;;-1:-1:-1;;;;;56698:35:3;;;;56678:5;56698:35;;;;;;;;;;;;;;;;;56744:27;:25;:27::i;:::-;56405:373;;:::o;42692:495::-;-1:-1:-1;;;;;42783:24:3;;42759:4;42783:24;;;:7;:24;;;;;:33;;;42775:86;;;;-1:-1:-1;;;42775:86:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42893:13;;-1:-1:-1;;;;;42893:13:3;42879:10;:27;;:50;;-1:-1:-1;42924:5:3;;-1:-1:-1;;;;;42924:5:3;42910:10;:19;42879:50;42871:102;;;;-1:-1:-1;;;42871:102:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43005:5;;-1:-1:-1;;;;;43005:5:3;42991:10;:19;;:36;;-1:-1:-1;43023:4:3;43014:13;;;;42991:36;42983:71;;;;;-1:-1:-1;;;42983:71:3;;;;;;;;;;;;-1:-1:-1;;;42983:71:3;;;;;;;;;;;;;;;-1:-1:-1;;;;;43065:35:3;;;;;;:18;:35;;;;;;;;;:43;;;;;-1:-1:-1;;43065:43:3;;;;;;;;43123:35;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;43123:35:3;;;;;;;;;;;;;;-1:-1:-1;43175:5:3;42692:495;-1:-1:-1;42692:495:3:o;2460:31:5:-;;;-1:-1:-1;;;2460:31:5;;;;;:::o;10432:351:3:-;;;;;:::o;57065:89::-;57135:12;57065:89;;:::o;19892:527::-;;;;;;;:::o;952:40:5:-;;;;:::o;45061:175:3:-;45115:10;45129:9;45115:23;45107:85;;;;-1:-1:-1;;;45107:85:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45202:27;:25;:27::i;:::-;45061:175::o;26934:401::-;27106:4;27112;27118;27135:9;27146:14;27162;27180:98;27220:7;27236:12;27251;27265;27180:39;:98::i;:::-;27134:144;;;;;;27301:3;27296:9;;;;;;;;27288:40;-1:-1:-1;27307:9:3;;-1:-1:-1;27318:9:3;-1:-1:-1;;26934:401:3;;;;;;;;;:::o;9523:586::-;-1:-1:-1;;;;;9715:26:3;;9611:4;9715:26;;;:18;:26;;;;;;;;9714:27;9706:54;;;;;-1:-1:-1;;;9706:54:3;;;;;;;;;;;;-1:-1:-1;;;9706:54:3;;;;;;;;;;;;;;;-1:-1:-1;;;;;9847:15:3;;;;;;:7;:15;;;;;:24;;;9842:92;;9899:23;9894:29;9887:36;;;;9842:92;9980:29;10002:6;9980:21;:29::i;:::-;10019:45;10042:6;10050;10058:5;10019:22;:45::i;:::-;10087:14;10082:20;10075:27;;9523:586;;;;;;:::o;39163:1476::-;39253:4;39320:5;;-1:-1:-1;;;;;39320:5:3;39306:10;:19;39302:132;;39348:75;39353:18;39373:49;39348:4;:75::i;39302:132::-;39509:34;;:::i;:::-;-1:-1:-1;39546:48:3;;;;;;;;;;;;39604:34;;:::i;:::-;-1:-1:-1;39641:48:3;;;;;;;;;3421:6;39641:48;;39703:61;39715:23;39641:48;39703:11;:61::i;:::-;39699:190;;;39787:91;39792:35;39829:48;39787:4;:91::i;39699:190::-;39899:34;;:::i;:::-;-1:-1:-1;39936:48:3;;;;;;;;;3569:6;39936:48;;39998:61;39936:48;40035:23;39998:11;:61::i;:::-;39994:190;;;40082:91;40087:35;40124:48;40082:4;:91::i;39994:190::-;40278:28;;;40371:62;;;;40505:89;;;;;;;;;;;;;;;;;;;;;;;;;40617:14;40612:20;;12856:340;13099:17;;:37;;;;;13135:1;13120:12;:16;13099:37;13095:95;;;13152:27;;;-1:-1:-1;;;13152:27:3;;;;;;;;;;;;-1:-1:-1;;;13152:27:3;;;;;;;;;;;;;;3054:26:5;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;3054:26:5;;-1:-1:-1;3054:26:5;:::o;34344:556:3:-;34408:4;34475:5;;-1:-1:-1;;;;;34475:5:3;34461:10;:19;34457:123;;34503:66;34508:18;34528:40;34503:4;:66::i;34457:123::-;34666:6;;;-1:-1:-1;;;;;34732:18:3;;;-1:-1:-1;;;;;;34732:18:3;;;;;;;34819:36;;;34666:6;;;;34819:36;;;;;;;;;;;;;;;;;;;;;;;34878:14;34866:27;34344:556;-1:-1:-1;;;34344:556:3:o;15545:312::-;15794:57;;25581:264;25648:4;25654;25660;25677:9;25688:14;25704;25722:65;25762:7;25778:1;25782;25785;25722:39;:65::i;:::-;25676:111;;;;;;25811:3;25806:9;;;;;;;;25798:40;25817:9;;-1:-1:-1;25817:9:3;-1:-1:-1;25581:264:3;-1:-1:-1;;;25581:264:3:o;42094:592::-;42163:4;42197:5;;-1:-1:-1;;;;;42197:5:3;42183:10;:19;42179:125;;42225:68;42230:18;42250:42;42225:4;:68::i;42179:125::-;42392:13;;;-1:-1:-1;;;;;42475:32:3;;;-1:-1:-1;;;;;;42475:32:3;;;;;;;42592:49;;;42392:13;;;42592:49;;;42627:13;;;;42592:49;;;;;;;;;;;;;;;;42664:14;42659:20;;18168:1260;-1:-1:-1;;;;;18441:23:3;;18365:4;18441:23;;;:7;:23;;;;;:32;;;18440:33;;:72;;-1:-1:-1;;;;;;18478:25:3;;;;;;:7;:25;;;;;:34;;;18477:35;18440:72;18436:139;;;18540:23;18535:29;18528:36;;;;18436:139;18661:9;18674:14;18692:37;18720:8;18692:27;:37::i;:::-;18660:69;;-1:-1:-1;18660:69:3;;-1:-1:-1;18750:14:3;;-1:-1:-1;18743:3:3;:21;;;;;;;;;18739:68;;18792:3;18787:9;;;;;;;;18780:16;;;;;;18739:68;18820:14;18816:86;;18862:28;18857:34;;18816:86;19000:18;19028:14;-1:-1:-1;;;;;19021:42:3;;19064:8;19021:52;;;;;;;;;;;;;-1:-1:-1;;;;;19021:52:3;-1:-1:-1;;;;;19021:52:3;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;19021:52:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;19021:52:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;19021:52:3;19138:36;;;19021:52;19138:36;;;;;19153:19;;19138:36;;19021:52;;-1:-1:-1;19084:17:3;;;;19120:70;;19021:52;19120:17;:70::i;:::-;19083:107;;-1:-1:-1;19083:107:3;-1:-1:-1;19215:18:3;19204:7;:29;;;;;;;;;19200:89;;19261:16;19256:22;19249:29;;;;;;;;;19200:89;19316:8;19302:11;:22;19298:86;;;19352:20;19347:26;;19298:86;19406:14;19394:27;;;;;;;18168:1260;;;;;;;;:::o;53449:933::-;53573:6;53568:808;53589:7;:14;53585:1;:18;53568:808;;;53624:13;53640:7;53648:1;53640:10;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;53672:24:3;;;;;;:7;:24;;;;;;;:33;53640:10;;-1:-1:-1;53672:33:3;;53664:67;;;;;-1:-1:-1;;;53664:67:3;;;;;;;;;;;;-1:-1:-1;;;53664:67:3;;;;;;;;;;;;;;;53762:4;53749:17;;;;53745:357;;;53786:22;;:::i;:::-;53811:37;;;;;;;;53826:6;-1:-1:-1;;;;;53826:18:3;;:20;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;53826:20:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;53826:20:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;53826:20:3;53811:37;;53786:62;-1:-1:-1;53866:51:3;53896:6;53786:62;53866:21;:51::i;:::-;53940:6;53935:153;53956:7;:14;53952:1;:18;53935:153;;;53999:70;54030:6;54039:7;54047:1;54039:10;;;;;;;;;;;;;;54051:11;54064:4;53999:22;:70::i;:::-;53972:3;;53935:153;;;;53745:357;;54132:4;54119:17;;;;54115:251;;;54156:38;54186:6;54156:21;:38::i;:::-;54217:6;54212:140;54233:7;:14;54229:1;:18;54212:140;;;54276:57;54307:6;54316:7;54324:1;54316:10;;;;;;;;;;;;;;54328:4;54276:22;:57::i;:::-;54249:3;;54212:140;;;;54115:251;-1:-1:-1;53605:3:3;;53568:808;;54574:275;54637:21;:19;:21::i;:::-;54629:65;;;;;-1:-1:-1;;;54629:65:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;54720:8;;;54738:20;;;;54773:31;;;;;;;;;;;;;;;;;;;;;;;;;54815:27;:25;:27::i;3375:58:5:-;;;;;;;;;;;;-1:-1:-1;;;;;3375:58:5;;;-1:-1:-1;;;3375:58:5;;;;;:::o;2669:52::-;;;;;;;;;;;;;;;:::o;2613:50::-;;;;;;;;;;;;;;;:::o;2743::3:-;2785:8;2743:50;:::o;663:25:5:-;;;-1:-1:-1;;;;;663:25:5;;:::o;2536:34::-;;;-1:-1:-1;;;2536:34:5;;;;;:::o;3501:58::-;;;;;;;;;;;;-1:-1:-1;;;;;3501:58:5;;;-1:-1:-1;;;3501:58:5;;;;;:::o;2114:41::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;43700:371:3:-;43794:13;;43756:4;;-1:-1:-1;;;;;43794:13:3;43780:10;:27;;:50;;-1:-1:-1;43825:5:3;;-1:-1:-1;;;;;43825:5:3;43811:10;:19;43780:50;43772:102;;;;-1:-1:-1;;;43772:102:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43906:5;;-1:-1:-1;;;;;43906:5:3;43892:10;:19;;:36;;-1:-1:-1;43924:4:3;43915:13;;;;43892:36;43884:71;;;;;-1:-1:-1;;;43884:71:3;;;;;;;;;;;;-1:-1:-1;;;43884:71:3;;;;;;;;;;;;;;;43966:22;:30;;;;;-1:-1:-1;;;43966:30:3;;-1:-1:-1;;;;43966:30:3;;;;;;;;;;44011:31;;;;;;;;;;;;;;;;;;-1:-1:-1;;;44011:31:3;;;;;;;;;;;;;;-1:-1:-1;44059:5:3;43700:371::o;4334:161::-;-1:-1:-1;;;;;4437:24:3;;;4414:4;4437:24;;;:7;:24;;;;;;;;:51;;;;;:42;;;;:51;;;;;;4334:161;;;;:::o;1117:21:5:-;;;;:::o;57263:122:3:-;57336:42;57263:122;:::o;40958:654::-;41015:4;41049:5;;-1:-1:-1;;;;;41049:5:3;41035:10;:19;41031:121;;41077:64;41082:18;41102:38;41077:4;:64::i;41031:121::-;-1:-1:-1;;;;;41166:24:3;;;;;;:7;:24;;;;;:33;;;41162:139;;;41222:68;41227:27;41256:33;41222:4;:68::i;41162:139::-;41311:6;-1:-1:-1;;;;;41311:15:3;;:17;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;41311:17:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;41311:17:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;41415:70:3;;;;;;;;41433:4;41415:70;;;-1:-1:-1;41311:17:3;41415:70;;;;;;;;;;;;-1:-1:-1;;;;;41388:24:3;;;;:7;:24;;;;;;;:97;;;;;;;-1:-1:-1;;41388:97:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41496:35;41404:6;41496:18;:35::i;:::-;41547:20;;;-1:-1:-1;;;;;41547:20:3;;;;;;;;;;;;;;;41590:14;41578:27;40958:654;-1:-1:-1;;40958:654:3:o;2852:47::-;2895:4;2852:47;:::o;3162:20:5:-;;;;:::o;3895:170:3:-;3956:15;3983:24;4010:13;:22;4024:7;-1:-1:-1;;;;;4010:22:3;-1:-1:-1;;;;;4010:22:3;;;;;;;;;;;;3983:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;3983:49:3;;;;;;;;;;;;;;;;-1:-1:-1;3983:49:3;;3895:170;-1:-1:-1;;;;;;;3895:170:3:o;2576:31:5:-;;;-1:-1:-1;;;2576:31:5;;;;;:::o;56962:97:3:-;57008:15;57042:10;57035:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;57035:17:3;;;;;;;;;;;;;;;;;;;;;;;56962:97;:::o;3676:69:5:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;364:40::-;;;-1:-1:-1;;;;;364:40:5;;:::o;23198:761:3:-;23408:22;;23304:4;;-1:-1:-1;;;23408:22:3;;;;23407:23;23399:54;;;;;-1:-1:-1;;;23399:54:3;;;;;;;;;;;;-1:-1:-1;;;23399:54:3;;;;;;;;;;;;;;;23584:12;23599:50;23621:6;23629:3;23634:14;23599:21;:50::i;:::-;23584:65;-1:-1:-1;23663:31:3;;23659:76;;23717:7;-1:-1:-1;23710:14:3;;23659:76;23781:29;23803:6;23781:21;:29::i;:::-;23820:42;23843:6;23851:3;23856:5;23820:22;:42::i;:::-;23872;23895:6;23903:3;23908:5;23872:22;:42::i;4754:368::-;4818:13;4843:8;4854:7;:14;4843:25;;4879:21;4914:3;4903:15;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;4903:15:3;-1:-1:-1;4879:39:3;-1:-1:-1;4933:6:3;4928:163;4949:3;4945:1;:7;4928:163;;;4973:13;4996:7;5004:1;4996:10;;;;;;;;;;;;;;4973:34;;5040:39;5060:6;5068:10;5040:19;:39::i;:::-;5035:45;;;;;;;;5022:7;5030:1;5022:10;;;;;;;;;;;;;;;;;:58;-1:-1:-1;4954:3:3;;4928:163;;;-1:-1:-1;5108:7:3;4754:368;-1:-1:-1;;;4754:368:3:o;32139:1949::-;32395:6;;;:49;;;-1:-1:-1;;;32395:49:3;;-1:-1:-1;;;;;32395:49:3;;;;;;;;;;;;32275:4;;;;;;32395:6;;;:25;;:49;;;;;;;;;;;;;;;:6;:49;;;5:2:-1;;;;30:1;27;20:12;5:2;32395:49:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;32395:49:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32395:49:3;32485:6;;;:51;;;-1:-1:-1;;;32485:51:3;;-1:-1:-1;;;;;32485:51:3;;;;;;;;;;;;32395:49;;-1:-1:-1;32454:28:3;;32485:6;;;;;:25;;:51;;;;;32395:49;;32485:51;;;;;;;;:6;:51;;;5:2:-1;;;;30:1;27;20:12;5:2;32485:51:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;32485:51:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;32485:51:3;;-1:-1:-1;32550:26:3;;;:58;;-1:-1:-1;32580:28:3;;32550:58;32546:124;;;32637:17;32624:35;-1:-1:-1;32657:1:3;;-1:-1:-1;32624:35:3;;-1:-1:-1;;32624:35:3;32546:124;33055:25;33090:16;-1:-1:-1;;;;;33083:43:3;;:45;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;33083:45:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;33083:45:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;33083:45:3;;-1:-1:-1;33164:16:3;33190:20;;:::i;:::-;33220:22;;:::i;:::-;33252:16;;:::i;:::-;33278:17;33329:59;33336:28;;33366:21;33329:6;:59::i;:::-;33306:82;-1:-1:-1;33306:82:3;-1:-1:-1;33413:18:3;33402:7;:29;;;;;;;;;33398:94;;33460:16;33455:22;33447:34;-1:-1:-1;33479:1:3;;-1:-1:-1;33447:34:3;;-1:-1:-1;;;;;;;;33447:34:3;33398:94;33527:53;33534:23;33559:20;33527:6;:53::i;:::-;33502:78;-1:-1:-1;33502:78:3;-1:-1:-1;33605:18:3;33594:7;:29;;;;;;;;;33590:94;;33652:16;33647:22;;33590:94;33713:30;33720:9;33731:11;33713:6;:30::i;:::-;33694:49;-1:-1:-1;33694:49:3;-1:-1:-1;33768:18:3;33757:7;:29;;;;;;;;;33753:94;;33815:16;33810:22;;33753:94;33882:43;33900:5;33907:17;33882;:43::i;:::-;33857:68;-1:-1:-1;33857:68:3;-1:-1:-1;33950:18:3;33939:7;:29;;;;;;;;;33935:94;;33997:16;33992:22;;33935:94;34052:14;34039:42;-1:-1:-1;34069:11:3;;-1:-1:-1;;;;;;;;32139:1949:3;;;;;;;:::o;3862:69:5:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;4008:43::-;;;;;;;;;;;;;:::o;55015:288:3:-;55091:21;:19;:21::i;:::-;55083:64;;;;;-1:-1:-1;;;55083:64:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;55163:6;55158:101;55179:7;:14;55175:1;:18;55158:101;;;55214:34;55237:7;55245:1;55237:10;;;;;;;;;;;;;;55214:22;:34::i;:::-;55195:3;;55158:101;;;;55269:27;:25;:27::i;20872:960::-;21163:19;;21059:4;;-1:-1:-1;;;21163:19:3;;;;21162:20;21154:48;;;;;-1:-1:-1;;;21154:48:3;;;;;;;;;;;;-1:-1:-1;;;21154:48:3;;;;;;;;;;;;;;;-1:-1:-1;;;;;21274:25:3;;;;;;:7;:25;;;;;:34;;;21273:35;;:72;;-1:-1:-1;;;;;;21313:23:3;;;;;;:7;:23;;;;;:32;;;21312:33;21273:72;21269:139;;;21373:23;21368:29;;21269:139;21471:14;-1:-1:-1;;;;;21464:34:3;;:36;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;21464:36:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;21464:36:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;21464:36:3;21422:38;;;-1:-1:-1;;;21422:38:3;;;;-1:-1:-1;;;;;21422:78:3;;;;:36;;;;;:38;;;;;21464:36;;21422:38;;;;;;;:36;:38;;;5:2:-1;;;;30:1;27;20:12;5:2;21422:38:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;21422:38:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;21422:38:3;-1:-1:-1;;;;;21422:78:3;;21418:148;;21528:26;21523:32;;21418:148;21612:39;21634:16;21612:21;:39::i;:::-;21661:57;21684:16;21702:8;21712:5;21661:22;:57::i;:::-;21728:59;21751:16;21769:10;21781:5;21728:22;:59::i;:::-;21810:14;21798:27;20872:960;-1:-1:-1;;;;;;20872:960:3:o;38467:403::-;38527:4;38594:5;;-1:-1:-1;;;;;38594:5:3;38580:10;:19;38576:121;;38622:64;38627:18;38647:38;38622:4;:64::i;38576:121::-;38727:9;;;38746:24;;;;38785:40;;;;;;;;;;;;;;;;;;;;;;;;;38848:14;38843:20;;13628:1618;-1:-1:-1;;;;;13826:28:3;;13722:4;13826:28;;;:20;:28;;;;;;;;13825:29;13817:58;;;;;-1:-1:-1;;;13817:58:3;;;;;;;;;;;;-1:-1:-1;;;13817:58:3;;;;;;;;;;;;;;;-1:-1:-1;;;;;13891:15:3;;;;;;:7;:15;;;;;:24;;;13886:92;;13943:23;13938:29;;13886:92;-1:-1:-1;;;;;13993:15:3;;;;;;;:7;:15;;;;;;;;:43;;;;;:33;;;;:43;;;;;;13988:562;;14137:10;-1:-1:-1;;;;;14137:20:3;;;14129:54;;;;;-1:-1:-1;;;14129:54:3;;;;;;;;;;;;-1:-1:-1;;;14129:54:3;;;;;;;;;;;;;;;14251:9;14263:49;14290:10;14303:8;14263:19;:49::i;:::-;14251:61;-1:-1:-1;14337:14:3;14330:3;:21;;;;;;;;;14326:76;;14383:3;14378:9;;;;;;;;14371:16;;;;;14326:76;-1:-1:-1;;;;;14495:15:3;;;;;;;:7;:15;;;;;;;;:43;;;;;:33;;;;:43;;;;;;14488:51;;;;13988:562;;14564:6;;;:41;;;-1:-1:-1;;;14564:41:3;;-1:-1:-1;;;;;14564:41:3;;;;;;;;;;;;:6;;;;;:25;;:41;;;;;;;;;;;;;;;:6;:41;;;5:2:-1;;;;30:1;27;20:12;5:2;14564:41:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;14564:41:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;14564:41:3;14560:107;;14638:17;14633:23;;14560:107;14678:9;14691:14;14709:82;14749:8;14766:6;14775:1;14778:12;14709:39;:82::i;:::-;14677:114;;-1:-1:-1;14677:114:3;;-1:-1:-1;14812:14:3;;-1:-1:-1;14805:3:3;:21;;;;;;;;;14801:68;;14854:3;14849:9;;;;;;;;14842:16;;;;;;14801:68;14882:13;;14878:85;;14923:28;14918:34;;14878:85;15009:22;;:::i;:::-;15034:45;;;;;;;;15056:6;-1:-1:-1;;;;;15049:26:3;;:28;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;15049:28:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;15049:28:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;15049:28:3;15034:45;;15009:70;-1:-1:-1;15089:42:3;15111:6;15009:70;15089:21;:42::i;:::-;15141:60;15164:6;15172:8;15182:11;15195:5;15141:22;:60::i;:::-;15224:14;15212:27;13628:1618;-1:-1:-1;;;;;;;13628:1618:3:o;1240:49:5:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;1240:49:5;;-1:-1:-1;1240:49:5;;-1:-1:-1;1240:49:5:o;469:47::-;;;-1:-1:-1;;;;;469:47:5;;:::o;36587:1606:3:-;36684:4;36751:5;;-1:-1:-1;;;;;36751:5:3;36737:10;:19;36733:128;;36779:71;36784:18;36804:45;36779:4;:71::i;:::-;36772:78;;;;36733:128;-1:-1:-1;;;;;36930:24:3;;36906:21;36930:24;;;:7;:24;;;;;36969:15;;;;36964:128;;37007:74;37012:23;37037:43;37007:4;:74::i;:::-;37000:81;;;;;36964:128;37102:33;;:::i;:::-;-1:-1:-1;37138:44:3;;;;;;;;;;;;37235:20;;:::i;:::-;-1:-1:-1;37258:44:3;;;;;;;;;3276:6;37258:44;;37316:46;37258:44;37339:22;37316:11;:46::i;:::-;37312:167;;;37385:83;37390:31;37423:44;37385:4;:83::i;:::-;37378:90;;;;;;;37312:167;37550:32;;;;;:74;;-1:-1:-1;37586:6:3;;;:33;;;-1:-1:-1;;;37586:33:3;;-1:-1:-1;;;;;37586:33:3;;;;;;;;;;;;:6;;;;;:25;;:33;;;;;;;;;;;;;;;:6;:33;;;5:2:-1;;;;30:1;27;20:12;5:2;37586:33:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;37586:33:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;37586:33:3;:38;37550:74;37546:184;;;37647:72;37652:17;37671:47;37647:4;:72::i;37546:184::-;37862:31;;;;;37903:61;;;;38063:85;;;-1:-1:-1;;;;;38063:85:3;;;;;;;;;;;;;;;;;;;;;;;;;;;38171:14;38159:27;36587:1606;-1:-1:-1;;;;;;;36587:1606:3:o;2497:33:5:-;;;-1:-1:-1;;;2497:33:5;;;;;:::o;805:31::-;;;;:::o;52606:95:3:-;52665:29;52675:6;52683:10;52665:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;52665:29:3;;;;;;;;;;;;;;;;;;;;;:9;:29::i;11225:441::-;11319:4;11335:12;11350:53;11372:6;11380:8;11390:12;11350:21;:53::i;:::-;11335:68;-1:-1:-1;11417:31:3;;11413:76;;11471:7;-1:-1:-1;11464:14:3;;11413:76;11535:29;11557:6;11535:21;:29::i;:::-;11574:47;11597:6;11605:8;11615:5;11574:22;:47::i;:::-;11644:14;11632:27;11225:441;-1:-1:-1;;;;;11225:441:3:o;6928:2127::-;6989:4;7005:13;7028;7005:37;;7131:9;7142:15;7159;7180:6;-1:-1:-1;;;;;7180:25:3;;7206:10;7180:37;;;;;;;;;;;;;-1:-1:-1;;;;;7180:37:3;-1:-1:-1;;;;;7180:37:3;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;7180:37:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;7180:37:3;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;7180:37:3;;;;;;;;;;;;;-1:-1:-1;7180:37:3;;-1:-1:-1;7180:37:3;-1:-1:-1;7235:9:3;;7227:59;;;;-1:-1:-1;;;7227:59:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7381:15;;7377:125;;7419:72;7424:28;7454:36;7419:4;:72::i;:::-;7412:79;;;;;;;;7377:125;7592:12;7607:60;7629:13;7644:10;7656;7607:21;:60::i;:::-;7592:75;-1:-1:-1;7681:12:3;;7677:121;;7716:71;7727:15;7744:33;7779:7;7716:10;:71::i;:::-;7709:78;;;;;;;;;7677:121;-1:-1:-1;;;;;7838:24:3;;7808:27;7838:24;;;:7;:24;;;;;;;;7984:10;7953:42;;:30;;;:42;;;;;;;;;7948:101;;8023:14;8011:27;;;;;;;;;;7948:101;8150:10;8119:42;;;;:30;;;:42;;;;;;;;8112:49;;-1:-1:-1;;8112:49:3;;;8317:13;:25;;;;;;8285:57;;;;;;;;;;;;;;;;;:29;;:57;;;8317:25;8285:57;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8285:57:3;;;;;;;;;;;;;;;;-1:-1:-1;;8363:20:3;;8285:57;;-1:-1:-1;8363:20:3;;-1:-1:-1;8352:8:3;;-1:-1:-1;;8424:157:3;8445:3;8441:1;:7;8424:157;;;8493:6;-1:-1:-1;;;;;8473:26:3;:13;8487:1;8473:16;;;;;;;;;;;;;;-1:-1:-1;;;;;8473:26:3;;8469:102;;;8532:1;8519:14;;8551:5;;8469:102;8450:3;;8424:157;;;;8707:3;8694:10;:16;8687:24;;;;8854:10;8810:27;8840:25;;;:13;:25;;;;;8911:17;;8840:25;;-1:-1:-1;;8911:21:3;;;8900:33;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8900:33:3;8875:10;8886;8875:22;;;;;;;;;;;;;;;;;:58;;-1:-1:-1;;;;;;8875:58:3;-1:-1:-1;;;;;8875:58:3;;;;;;;;;;8943:19;;;;-1:-1:-1;;8943:19:3;;;:::i;:::-;-1:-1:-1;8978:32:3;;;-1:-1:-1;;;;;8978:32:3;;;;8999:10;8978:32;;;;;;;;;;;;;;;;;9033:14;9021:27;6928:2127;-1:-1:-1;;;;;;;;;;;;6928:2127:3:o;177:20:5:-;;;-1:-1:-1;;;;;177:20:5;;:::o;47876:1086:3:-;-1:-1:-1;;;;;48010:23:3;;47972:35;48010:23;;;:15;:23;;;;;;;;48062:10;:18;;;;;;48010:23;;48109:16;:14;:16::i;:::-;48177:17;;48090:35;;-1:-1:-1;48135:16:3;;48154:42;;48090:35;;-1:-1:-1;;;48177:17:3;;;;48154:4;:42::i;:::-;48135:61;;48224:1;48210:11;:15;:34;;;;;48243:1;48229:11;:15;48210:34;48206:750;;;48260:17;48280:54;48292:6;-1:-1:-1;;;;;48285:27:3;;:29;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;48285:29:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;48285:29:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;48285:29:3;48316:17;48280:4;:54::i;:::-;48260:74;;48348:16;48367:30;48372:11;48385;48367:4;:30::i;:::-;48348:49;;48411:19;;:::i;:::-;48448:1;48433:12;:16;:78;;48490:21;;;;;;;;48508:1;48490:21;;;48433:78;;;48452:35;48461:11;48474:12;48452:8;:35::i;:::-;48411:100;;48525:19;;:::i;:::-;48552:37;;;;;;;;;48570:17;;-1:-1:-1;;;;;48570:17:3;48552:37;;48547:50;;48591:5;48547:4;:50::i;:::-;48525:72;;48637:185;;;;;;;;48678:53;48686:5;:14;;;48678:53;;;;;;;;;;;;;;;;;:7;:53::i;:::-;-1:-1:-1;;;;;48637:185:3;;;;;48756:51;48763:11;48756:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;48756:51:3;;;:6;:51::i;:::-;48637:185;;;;;;;-1:-1:-1;;;;;48611:23:3;;;;;;:15;:23;;;;;;;;:211;;;;;;;;;;;;-1:-1:-1;;;48611:211:3;-1:-1:-1;;;;;48611:211:3;;;-1:-1:-1;;;;;;48611:211:3;;;;;;;;;;;;;;-1:-1:-1;48206:750:3;;-1:-1:-1;;;48206:750:3;;48843:15;;48839:117;;48894:51;48901:11;48894:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;48894:51:3;;;:6;:51::i;:::-;48874:71;;;;;;;-1:-1:-1;;;48874:71:3;-1:-1:-1;;;;;48874:71:3;;;;;;47876:1086;;;;;;:::o;50596:1040::-;-1:-1:-1;;;;;50769:23:3;;50731:35;50769:23;;;:15;:23;;;;;50802:25;;:::i;:::-;-1:-1:-1;50830:37:3;;;;;;;;;50848:17;;-1:-1:-1;;;;;50848:17:3;50830:37;;50877:27;;:::i;:::-;-1:-1:-1;50907:55:3;;;;;;;;;-1:-1:-1;;;;;50925:25:3;;;-1:-1:-1;50925:25:3;;;:17;:25;;;;;:35;;;;;;;;;;;;;;50907:55;;51010:20;;50972:35;;;;;;:58;;;;51045:22;;:26;51041:589;;51087:24;;:::i;:::-;51114:32;51119:11;51132:13;51114:4;:32::i;:::-;51087:59;;51160:19;51182:69;51194:6;-1:-1:-1;;;;;51187:34:3;;51222:8;51187:44;;;;;;;;;;;;;-1:-1:-1;;;;;51187:44:3;-1:-1:-1;;;;;51187:44:3;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;51187:44:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;51187:44:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51187:44:3;51233:17;51182:4;:69::i;:::-;51160:91;;51265:18;51286:32;51291:14;51307:10;51286:4;:32::i;:::-;-1:-1:-1;;;;;51360:21:3;;51332:20;51360:21;;;:11;:21;;;;;;51265:53;;-1:-1:-1;51332:20:3;51355:42;;51265:53;51355:4;:42::i;:::-;51332:65;;51435:79;51448:8;51458:15;51475:13;:38;;2785:8;51475:38;;;51491:1;51475:38;51435:12;:79::i;:::-;-1:-1:-1;;;;;51411:21:3;;;;;;;:11;:21;;;;;;;;;:103;;;;51598:20;;51533:86;;;;;;;;;;;51411:21;;51533:86;;;;;;;;;;;;;;;51041:589;;;;;50596:1040;;;;;;;:::o;1855:149:8:-;1916:4;1937:33;1950:3;1945:9;;;;;;;;1961:4;1956:10;;;;;;;;1937:33;;;;;;;;;;;;;1968:1;1937:33;;;;;;;;;;;;;1993:3;1988:9;;;;;;;7723:147:9;7849:14;7832:13;;:31;;;7723:147::o;7517:139::-;7635:14;7619:13;;:30;;7517:139::o;45242:1298:3:-;45298:27;45328:10;45298:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;45298:40:3;;;;;;;;;;;;;;;;-1:-1:-1;45298:40:3;;-1:-1:-1;45354:6:3;;-1:-1:-1;;;;45349:294:3;45370:11;:18;45366:1;:22;45349:294;;;45409:13;45425:11;45437:1;45425:14;;;;;;;;;;;;;;45409:30;;45453:22;;:::i;:::-;45478:37;;;;;;;;45493:6;-1:-1:-1;;;;;45493:18:3;;:20;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45493:20:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45493:20:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45493:20:3;45478:37;;45453:62;-1:-1:-1;45529:38:3;45559:6;45529:21;:38::i;:::-;45581:51;45611:6;45620:11;45581:21;:51::i;:::-;-1:-1:-1;;45390:3:3;;45349:294;;;;45653:23;;:::i;:::-;45679:18;;;;;;;;45694:1;45679:18;;;45653:44;;45707:22;45742:11;:18;45732:29;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;45707:54:3;-1:-1:-1;45776:6:3;45771:438;45792:11;:18;45788:1;:22;45771:438;;;45831:13;45847:11;45859:1;45847:14;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;45879:24:3;;;;;;:7;:24;;;;;;;:33;;;45847:14;;-1:-1:-1;45879:33:3;;45875:324;;;45932:21;;:::i;:::-;45956:50;;;;;;;;;;45971:6;;-1:-1:-1;;;45971:33:3;;;-1:-1:-1;;;;;45971:33:3;;;;;;;;;45956:50;;;;45971:6;;;:25;;:33;;;;;45956:50;45971:33;;;;;;:6;:33;;;5:2:-1;;;;30:1;27;20:12;5:2;45971:33:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45971:33:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45971:33:3;45956:50;;45932:74;-1:-1:-1;46024:18:3;;:::i;:::-;46045:39;46050:10;46062:6;-1:-1:-1;;;;;46062:19:3;;:21;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46062:21:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;46062:21:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;46062:21:3;46045:4;:39::i;:::-;46024:60;;46117:7;46102:9;46112:1;46102:12;;;;;;;;;;;;;:22;;;;46157:27;46162:12;46176:7;46157:4;:27::i;:::-;46142:42;;45875:324;;;-1:-1:-1;45812:3:3;;45771:438;;;-1:-1:-1;46224:6:3;46219:315;46240:11;:18;46236:1;:22;46219:315;;;46279:13;46295:10;46306:1;46295:13;;;;;;;;;;;;;;;;;46338:21;;-1:-1:-1;;;;;46295:13:3;;;;-1:-1:-1;46338:80:3;;46417:1;46338:80;;;46366:48;46371:8;;46381:32;46386:9;46396:1;46386:12;;;;;;;;;;;;;;46400;46381:4;:32::i;:::-;46366:4;:48::i;:::-;-1:-1:-1;;;;;46432:27:3;;;;;;:10;:27;;;;;;;;;:38;;;46489:34;;;;;;;46322:96;;-1:-1:-1;46432:27:3;;46489:34;;;;;;;;;;;-1:-1:-1;;46260:3:3;;46219:315;;28100:3511;28281:5;28288:4;28294;28311:37;;:::i;:::-;-1:-1:-1;;;;;28508:22:3;;28395:9;28508:22;;;:13;:22;;;;;;;;28483:47;;;;;;;;;;;;;;;;;28395:9;;28483:22;;:47;28508:22;28483:47;;;28508:22;28483:47;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;28483:47:3;;;;;;;;;;;;;;;;-1:-1:-1;28483:47:3;;-1:-1:-1;28545:6:3;;-1:-1:-1;;;;28540:2728:3;28561:6;:13;28557:1;:17;28540:2728;;;28595:12;28610:6;28617:1;28610:9;;;;;;;;;;;;;;28595:24;;28777:5;-1:-1:-1;;;;;28777:24:3;;28802:7;28777:33;;;;;;;;;;;;;-1:-1:-1;;;;;28777:33:3;-1:-1:-1;;;;;28777:33:3;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;28777:33:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;28777:33:3;;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;28777:33:3;;;;;;;;;;;;;;;;;28748:25;;28701:109;28728:18;;;28701:109;;;;28708:18;;;28701:109;;;;28777:33;-1:-1:-1;28828:9:3;;28824:164;;-1:-1:-1;28946:20:3;;-1:-1:-1;28968:1:3;;-1:-1:-1;28968:1:3;;-1:-1:-1;28938:35:3;;-1:-1:-1;;;;;28938:35:3;28824:164;29025:65;;;;;;;;;-1:-1:-1;;;;;29040:23:3;;;-1:-1:-1;29040:23:3;;;:7;:23;;;;;:48;;;29025:65;;29001:21;;;:89;;;;29124:42;;;;;;;-1:-1:-1;;;29139:25:3;29124:42;;29104:17;;;:62;29261:6;;;:32;;-1:-1:-1;;;29261:32:3;;;;;;;;;;;:6;;;:25;;:32;;;;;29025:65;29261:32;;;;;:6;:32;;;5:2:-1;;;;30:1;27;20:12;5:2;29261:32:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29261:32:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;29261:32:3;29234:24;;;:59;;;29307:100;;-1:-1:-1;29368:17:3;;-1:-1:-1;29387:1:3;;-1:-1:-1;29387:1:3;;-1:-1:-1;29360:32:3;;-1:-1:-1;;;;;29360:32:3;29307:100;29439:41;;;;;;;;;29454:24;;;;29439:41;;29420:16;;;:60;;;29625:21;;;;29648:17;;;;29617:67;;:7;:67::i;:::-;29595:18;;;29588:96;;-1:-1:-1;29710:18:3;29702:4;:26;;;;;;;;;29698:96;;-1:-1:-1;29756:16:3;;-1:-1:-1;29774:1:3;;-1:-1:-1;29774:1:3;;-1:-1:-1;29748:31:3;;-1:-1:-1;;;;;29748:31:3;29698:96;29899:84;29924:4;:18;;;29944:4;:18;;;29964:4;:18;;;29899:24;:84::i;:::-;29870:113;;;-1:-1:-1;29877:18:3;30001:4;:26;;;;;;;;;29997:96;;-1:-1:-1;30055:16:3;;-1:-1:-1;30073:1:3;;-1:-1:-1;30073:1:3;;-1:-1:-1;30047:31:3;;-1:-1:-1;;;;;30047:31:3;29997:96;30210:89;30235:4;:16;;;30253:4;:18;;;30273:4;:25;;;30210:24;:89::i;:::-;30181:25;;;30174:125;;-1:-1:-1;30325:18:3;30317:4;:26;;;;;;;;;30313:96;;-1:-1:-1;30371:16:3;;-1:-1:-1;30389:1:3;;-1:-1:-1;30389:1:3;;-1:-1:-1;30363:31:3;;-1:-1:-1;;;;;30363:31:3;30313:96;30502:12;-1:-1:-1;;;;;30493:21:3;:5;-1:-1:-1;;;;;30493:21:3;;30489:769;;;30675:85;30700:4;:18;;;30720:12;30734:4;:25;;;30675:24;:85::i;:::-;30646:25;;;30639:121;;-1:-1:-1;30790:18:3;30782:4;:26;;;;;;;;;30778:104;;-1:-1:-1;30840:16:3;;-1:-1:-1;30858:1:3;;-1:-1:-1;30858:1:3;;-1:-1:-1;30832:31:3;;-1:-1:-1;;;;;30832:31:3;30778:104;31039:83;31064:4;:16;;;31082:12;31096:4;:25;;;31039:24;:83::i;:::-;31010:25;;;31003:119;;-1:-1:-1;31152:18:3;31144:4;:26;;;;;;;;;31140:104;;-1:-1:-1;31202:16:3;;-1:-1:-1;31220:1:3;;-1:-1:-1;31220:1:3;;-1:-1:-1;31194:31:3;;-1:-1:-1;;;;;31194:31:3;31140:104;-1:-1:-1;28576:3:3;;28540:2728;;;-1:-1:-1;31374:25:3;;;;31353:18;;:46;31349:256;;;-1:-1:-1;;;31460:25:3;;;;31439:18;;31423:14;;-1:-1:-1;31439:46:3;;-1:-1:-1;31423:14:3;;-1:-1:-1;31415:74:3;;31349:256;-1:-1:-1;;31575:18:3;;31547:25;;;;;31528:14;;-1:-1:-1;31528:14:3;;-1:-1:-1;31547:46:3;;;;;-1:-1:-1;31520:74:3;;-1:-1:-1;31520:74:3;46693:1030;-1:-1:-1;;;;;46797:23:3;;46759:35;46797:23;;;:15;:23;;;;;;;;46849:10;:18;;;;;;46797:23;;46896:16;:14;:16::i;:::-;46964:17;;46877:35;;-1:-1:-1;46922:16:3;;46941:42;;46877:35;;-1:-1:-1;;;46964:17:3;;;;46941:4;:42::i;:::-;46922:61;;47011:1;46997:11;:15;:34;;;;;47030:1;47016:11;:15;46997:34;46993:724;;;47047:17;47074:6;-1:-1:-1;;;;;47067:26:3;;:28;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;47067:28:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47067:28:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;47067:28:3;;-1:-1:-1;47109:16:3;47128:30;47133:11;47146;47128:4;:30::i;:::-;47109:49;;47172:19;;:::i;:::-;47209:1;47194:12;:16;:78;;47251:21;;;;;;;;47269:1;47251:21;;;47194:78;;;47213:35;47222:11;47235:12;47213:8;:35::i;:::-;47172:100;;47286:19;;:::i;:::-;47313:37;;;;;;;;;47331:17;;-1:-1:-1;;;;;47331:17:3;47313:37;;47308:50;;47352:5;47308:4;:50::i;:::-;47286:72;;47398:185;;;;;;;;47439:53;47447:5;:14;;;47439:53;;;;;;;;;;;;;;;;;:7;:53::i;:::-;-1:-1:-1;;;;;47398:185:3;;;;;47517:51;47524:11;47517:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47517:51:3;;;:6;:51::i;:::-;47398:185;;;;;;;-1:-1:-1;;;;;47372:23:3;;;;;;:15;:23;;;;;;;;:211;;;;;;;;;;;;-1:-1:-1;;;47372:211:3;-1:-1:-1;;;;;47372:211:3;;;-1:-1:-1;;;;;;47372:211:3;;;;;;;;;;;;;;-1:-1:-1;46993:724:3;;-1:-1:-1;;;46993:724:3;;47604:15;;47600:117;;47655:51;47662:11;47655:51;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;47655:51:3;;;:6;:51::i;:::-;47635:71;;;;;;;-1:-1:-1;;;47635:71:3;-1:-1:-1;;;;;47635:71:3;;;;;;46693:1030;;;;;:::o;49211:1036::-;-1:-1:-1;;;;;49354:23:3;;49316:35;49354:23;;;:15;:23;;;;;49387:25;;:::i;:::-;-1:-1:-1;49415:37:3;;;;;;;;;49433:17;;-1:-1:-1;;;;;49433:17:3;49415:37;;49462:27;;:::i;:::-;-1:-1:-1;49492:55:3;;;;;;;;;-1:-1:-1;;;;;49510:25:3;;;-1:-1:-1;49510:25:3;;;:17;:25;;;;;:35;;;;;;;;;;;;;;49492:55;;49595:20;;49557:35;;;;;;:58;;;;49630:22;;:27;:55;;;;-1:-1:-1;49661:20:3;;:24;;49630:55;49626:127;;;2895:4;49701:41;;49626:127;49763:24;;:::i;:::-;49790:32;49795:11;49808:13;49790:4;:32::i;:::-;49763:59;;49832:19;49861:6;-1:-1:-1;;;;;49854:24:3;;49879:8;49854:34;;;;;;;;;;;;;-1:-1:-1;;;;;49854:34:3;-1:-1:-1;;;;;49854:34:3;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49854:34:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49854:34:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;49854:34:3;;-1:-1:-1;49898:18:3;49919:32;49854:34;49940:10;49919:4;:32::i;:::-;-1:-1:-1;;;;;49989:21:3;;49961:20;49989:21;;;:11;:21;;;;;;49898:53;;-1:-1:-1;49961:20:3;49984:42;;49898:53;49984:4;:42::i;:::-;49961:65;;50060:79;50073:8;50083:15;50100:13;:38;;2785:8;50100:38;;50060:79;-1:-1:-1;;;;;50036:21:3;;;;;;;:11;:21;;;;;;;;;:103;;;;50219:20;;50154:86;;;;;;;;;;;50036:21;;50154:86;;;;;;;;;;;;;;;49211:1036;;;;;;;;;;:::o;26124:185::-;26201:5;26208:4;26214;26237:65;26277:7;26293:1;26297;26300;26237:39;:65::i;:::-;26230:72;;;;;;26124:185;;;;;:::o;2536:306:9:-;2613:9;2624:4;2641:13;2656:18;;:::i;:::-;2678:20;2688:1;2691:6;2678:9;:20::i;:::-;2640:58;;-1:-1:-1;2640:58:9;-1:-1:-1;2719:18:9;2712:3;:25;;;;;;;;;2708:71;;-1:-1:-1;2761:3:9;-1:-1:-1;2766:1:9;;-1:-1:-1;2753:15:9;;2708:71;2797:18;2817:17;2826:7;2817:8;:17::i;:::-;2789:46;;;;;;2536:306;;;;;;:::o;44789:146:3:-;44843:4;44880:5;;-1:-1:-1;;;;;44880:5:3;44866:10;:19;;:62;;-1:-1:-1;44903:25:3;;-1:-1:-1;;;;;44903:25:3;44889:10;:39;44866:62;44859:69;;44789:146;:::o;41618:245::-;41686:6;41681:135;41702:10;:17;41698:21;;41681:135;;;41773:6;-1:-1:-1;;;;;41749:31:3;:10;41760:1;41749:13;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41749:13:3;:31;;41741:64;;;;;-1:-1:-1;;;41741:64:3;;;;;;;;;;;;-1:-1:-1;;;41741:64:3;;;;;;;;;;;;;;;41721:4;;41681:135;;;-1:-1:-1;41825:10:3;27::-1;;39:1;23:18;;45:23;;-1:-1;41825:31:3;;;;;;;;-1:-1:-1;;;;;;41825:31:3;-1:-1:-1;;;;;41825:31:3;;;;;;;;;;41618:245::o;11672:851::-;-1:-1:-1;;;;;11800:15:3;;11779:4;11800:15;;;:7;:15;;;;;:24;;;11795:92;;11852:23;11847:29;;11795:92;-1:-1:-1;;;;;11995:15:3;;;;;;;:7;:15;;;;;;;;:43;;;;;:33;;;;:43;;;;;;11990:102;;12066:14;12061:20;;11990:102;12194:9;12207:14;12225:82;12265:8;12282:6;12291:12;12305:1;12225:39;:82::i;:::-;12193:114;;-1:-1:-1;12193:114:3;;-1:-1:-1;12328:14:3;;-1:-1:-1;12321:3:3;:21;;;;;;;;;12317:68;;12370:3;12365:9;;;;;;;12317:68;12398:13;;12394:85;;12439:28;12434:34;;5400:1144;-1:-1:-1;;;;;5527:24:3;;5480:5;5527:24;;;:7;:24;;;;;5567:21;;;;5562:132;;5660:23;5653:30;;;;;5562:132;-1:-1:-1;;;;;5708:40:3;;;;;;:30;;;:40;;;;;;;;:48;;:40;:48;5704:130;;;5809:14;5802:21;;;;;5704:130;5882:9;;-1:-1:-1;;;;;5848:23:3;;;;;;:13;:23;;;;;:30;:43;5844:140;;5952:21;5945:28;;;;;5844:140;-1:-1:-1;;;;;6365:40:3;;;;;;;:30;;;:40;;;;;;;;:47;;-1:-1:-1;;6365:47:3;6408:4;6365:47;;;;;;6422:13;:23;;;;;27:10:-1;;23:18;;;45:23;;6422:36:3;;;;;;;;;;;;;;-1:-1:-1;;;;;;6422:36:3;;;;;;;6474:31;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6523:14:3;;5400:1144;-1:-1:-1;;;5400:1144:3:o;6180:148:9:-;6235:9;6246:10;;:::i;:::-;6275:46;6282:18;;;;;;;;6297:1;6282:18;;;6302;;;;;;;;6317:1;6302:18;;;6275:6;:46::i;:::-;6268:53;;;;6180:148;;;;;:::o;6932:144::-;6999:9;7010:10;;:::i;:::-;7046;;7058;;7039:30;;7046:10;7039:6;:30::i;55309:922:3:-;-1:-1:-1;;;;;55400:15:3;;55376:21;55400:15;;;:7;:15;;;;;55433;;;;:23;;:15;:23;55425:61;;;;;-1:-1:-1;;;55425:61:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;55504:15;;;;;;:24;55496:62;;;;;-1:-1:-1;;;55496:62:3;;;;;;;;;;;;;;;;;;;;;;;;;;;;55569:15;;;:22;;-1:-1:-1;;55569:22:3;55587:4;55569:22;;;;;;55606:34;;;-1:-1:-1;;;;;55606:34:3;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;55655:23:3;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;;;55655:29:3;:34;:72;;;;-1:-1:-1;;;;;;55693:23:3;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;55693:29:3;;;;:34;55655:72;55651:282;;;55769:153;;;;;;;;2895:4;-1:-1:-1;;;;;55769:153:3;;;;;55851:56;55858:16;:14;:16::i;:::-;55851:56;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;55851:56:3;;;:6;:56::i;:::-;55769:153;;;;;;;-1:-1:-1;;;;;55743:23:3;;;;;;:15;:23;;;;;;;;:179;;;;;;;;;;;;-1:-1:-1;;;55743:179:3;-1:-1:-1;;;;;55743:179:3;;;-1:-1:-1;;;;;;55743:179:3;;;;;;;;;;;;;;55651:282;-1:-1:-1;;;;;55947:23:3;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;;;55947:29:3;:34;:72;;;;-1:-1:-1;;;;;;55985:23:3;;;;;;:15;:23;;;;;:29;-1:-1:-1;;;55985:29:3;;;;:34;55947:72;55943:282;;;56061:153;;;;;;;;2895:4;-1:-1:-1;;;;;56061:153:3;;;;;56143:56;56150:16;:14;:16::i;56143:56::-;56061:153;;;;;;;-1:-1:-1;;;;;56035:23:3;;;;;;:15;:23;;;;;;;;:179;;;;;;;;;;;;-1:-1:-1;;;56035:179:3;-1:-1:-1;;;;;56035:179:3;;;-1:-1:-1;;;;;;56035:179:3;;;;;;;;;;;;;;55309:922;;:::o;2122:183:8:-;2207:4;2228:43;2241:3;2236:9;;;;;;;;2252:4;2247:10;;;;;;;;2228:43;;;;;;;;;;;;;;;;;;;;;;;;;;;;2294:3;2289:9;;;;;;;9528:118:9;9581:4;9604:35;9609:1;9612;9604:35;;;;;;;;;;;;;-1:-1:-1;;;9604:35:9;;;:4;:35::i;11373:124::-;11432:4;11455:35;11460:17;11465:1;447:4;11460;:17::i;:::-;11479:10;;11455:4;:35::i;10693:120::-;10746:4;10769:37;10774:1;10777;10769:37;;;;;;;;;;;;;;;;;:4;:37::i;12245:145::-;12302:13;;:::i;:::-;12334:49;;;;;;;;12352:29;12357:20;12362:1;485:4;12357;:20::i;:::-;12379:1;12352:4;:29::i;:::-;12334:49;;12327:56;12245:145;-1:-1:-1;;;12245:145:9:o;8747:158::-;8818:13;;:::i;:::-;8850:48;;;;;;;;8868:28;8873:1;:10;;;8885:1;:10;;;8868:4;:28::i;8263:162::-;8339:7;8378:12;-1:-1:-1;;;8366:10:9;;8358:33;;;;-1:-1:-1;;;8358:33:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;8358:33:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8416:1:9;;8263:162;-1:-1:-1;;8263:162:9:o;8431:158::-;8506:6;8543:12;-1:-1:-1;;;8532:9:9;;8524:32;;;;-1:-1:-1;;;8524:32:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;9364:158:9;9435:13;;:::i;:::-;9467:48;;;;;;;;9485:28;9490:1;:10;;;9502:1;:10;;;9485:4;:28::i;10562:125::-;10624:4;485;10647:19;10652:1;10655;:10;;;10647:4;:19::i;:::-;:33;;;;;;;10562:125;-1:-1:-1;;;10562:125:9:o;8911:114::-;8964:4;8987:31;8992:1;8995;8987:31;;;;;;;;;;;;;-1:-1:-1;;;8987:31:9;;;:4;:31::i;52018:448:3:-;52106:4;52141:9;52126:11;:24;;:43;;;;;52168:1;52154:11;:15;52126:43;52122:310;;;52185:9;52202:16;:14;:16::i;:::-;52254:29;;;-1:-1:-1;;;52254:29:3;;52277:4;52254:29;;;;;;52185:34;;-1:-1:-1;52233:18:3;;-1:-1:-1;;;;;52254:14:3;;;;;:29;;;;;;;;;;;;;;:14;:29;;;5:2:-1;;;;30:1;27;20:12;5:2;52254:29:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52254:29:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52254:29:3;;-1:-1:-1;52301:28:3;;;52297:125;;52349:4;-1:-1:-1;;;;;52349:13:3;;52363:4;52369:11;52349:32;;;;;;;;;;;;;-1:-1:-1;;;;;52349:32:3;-1:-1:-1;;;;;52349:32:3;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;52349:32:3;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;52349:32:3;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;52406:1:3;;-1:-1:-1;52399:8:3;;-1:-1:-1;;;52399:8:3;52297:125;52122:310;;;-1:-1:-1;52448:11:3;;52018:448;-1:-1:-1;;52018:448:3:o;9976:131:9:-;10035:10;;:::i;:::-;10064:36;;;;;;;;10079:19;10084:1;:10;;;10096:1;10079:4;:19::i;11068:162::-;11133:10;;:::i;:::-;11162:61;;;;;;;;11177:44;11182:26;11187:1;:10;;;447:4;11182;:26::i;:::-;11210:10;;11177:4;:44::i;10113:119::-;10172:4;447;10195:19;10200:1;10203;:10;;;10195:4;:19::i;6422:278::-;6504:9;6515:10;;:::i;:::-;6538:13;6553;;:::i;:::-;6570:12;6577:1;6580;6570:6;:12::i;:::-;6537:45;;-1:-1:-1;6537:45:9;-1:-1:-1;6603:18:9;6596:3;:25;;;;;;;;;6592:72;;6645:3;;-1:-1:-1;6650:2:9;-1:-1:-1;6637:16:9;;6592:72;6680:13;6687:2;6691:1;6680:6;:13::i;:::-;6673:20;;;;;;6422:278;;;;;;:::o;2982:321::-;3079:9;3090:4;3107:13;3122:18;;:::i;:::-;3144:20;3154:1;3157:6;3144:9;:20::i;:::-;3106:58;;-1:-1:-1;3106:58:9;-1:-1:-1;3185:18:9;3178:3;:25;;;;;;;;;3174:71;;-1:-1:-1;3227:3:9;-1:-1:-1;3232:1:9;;-1:-1:-1;3219:15:9;;3174:71;3262:34;3270:17;3279:7;3270:8;:17::i;:::-;3289:6;3262:7;:34::i;2082:346::-;2151:9;2162:10;;:::i;:::-;2185:14;2201:19;2224:27;2232:1;:10;;;2244:6;2224:7;:27::i;:::-;2184:67;;-1:-1:-1;2184:67:9;-1:-1:-1;2273:18:9;2265:4;:26;;;;;;;;;2261:90;;-1:-1:-1;2321:18:9;;;;;;;;;-1:-1:-1;2321:18:9;;2315:4;;-1:-1:-1;2321:18:9;-1:-1:-1;2307:33:9;;2261:90;2389:31;;;;;;;;;;;;-1:-1:-1;;2389:31:9;;-1:-1:-1;2082:346:9;-1:-1:-1;;;;2082:346:9:o;7228:210::-;7408:12;447:4;7408:23;;;7228:210::o;4950:1116::-;5017:9;5028:10;;:::i;:::-;5052:14;5068:24;5096:31;5104:1;:10;;;5116:1;:10;;;5096:7;:31::i;:::-;5051:76;;-1:-1:-1;5051:76:9;-1:-1:-1;5149:18:9;5141:4;:26;;;;;;;;;5137:90;;-1:-1:-1;5197:18:9;;;;;;;;;-1:-1:-1;5197:18:9;;5191:4;;-1:-1:-1;5197:18:9;-1:-1:-1;5183:33:9;;5137:90;5539:14;;5596:42;524:10;5618:19;5596:7;:42::i;:::-;5538:100;;-1:-1:-1;5538:100:9;-1:-1:-1;5660:18:9;5652:4;:26;;;;;;;;;5648:90;;-1:-1:-1;5708:18:9;;;;;;;;;-1:-1:-1;5708:18:9;;5702:4;;-1:-1:-1;5708:18:9;-1:-1:-1;5694:33:9;;-1:-1:-1;;5694:33:9;5648:90;5749:14;5765:12;5781:51;5789:32;447:4;5781:7;:51::i;:::-;5748:84;;-1:-1:-1;5748:84:9;-1:-1:-1;5976:18:9;5968:4;:26;;;;;;;;;5961:34;;;;6034:24;;;;;;;;;;;;-1:-1:-1;;6034:24:9;;-1:-1:-1;4950:1116:9;-1:-1:-1;;;;;;;;4950:1116:9:o;876:503::-;937:9;948:10;;:::i;:::-;971:14;987:20;1011:22;1019:3;447:4;1011:7;:22::i;:::-;970:63;;-1:-1:-1;970:63:9;-1:-1:-1;1055:18:9;1047:4;:26;;;;;;;;;1043:90;;-1:-1:-1;1103:18:9;;;;;;;;;-1:-1:-1;1103:18:9;;1097:4;;-1:-1:-1;1103:18:9;-1:-1:-1;1089:33:9;;1043:90;1144:14;1160:13;1177:31;1185:15;1202:5;1177:7;:31::i;:::-;1143:65;;-1:-1:-1;1143:65:9;-1:-1:-1;1230:18:9;1222:4;:26;;;;;;;;;1218:90;;-1:-1:-1;1278:18:9;;;;;;;;;-1:-1:-1;1278:18:9;;1272:4;;-1:-1:-1;1278:18:9;-1:-1:-1;1264:33:9;;-1:-1:-1;;1264:33:9;1218:90;1346:25;;;;;;;;;;;;-1:-1:-1;;1346:25:9;;-1:-1:-1;876:503:9;-1:-1:-1;;;;;;876:503:9:o;9652:155::-;9733:4;9765:12;9757:6;;;;9749:29;;;;-1:-1:-1;;;9749:29:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;9749:29:9;-1:-1:-1;;;9795:5:9;;;9652:155::o;11968:111::-;12021:4;12044:28;12049:1;12052;12044:28;;;;;;;;;;;;;-1:-1:-1;;;12044:28:9;;;:4;:28::i;10819:243::-;10900:4;10920:6;;;:16;;-1:-1:-1;10930:6:9;;10920:16;10916:55;;;-1:-1:-1;10959:1:9;10952:8;;10916:55;10989:5;;;10993:1;10989;:5;:1;11012:5;;;;;:10;11024:12;11004:33;;;;;-1:-1:-1;;;11004:33:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;11004:33:9;-1:-1:-1;11054:1:9;10819:243;-1:-1:-1;;;;10819:243:9:o;9031:175::-;9112:4;9137:5;;;9168:12;9160:6;;;;9152:29;;;;-1:-1:-1;;;9152:29:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;1613:250:2;1669:9;;1705:5;;;1725:6;;;1721:136;;1755:18;;-1:-1:-1;1775:1:2;-1:-1:-1;1747:30:2;;1721:136;-1:-1:-1;1816:26:2;;-1:-1:-1;1844:1:2;;-1:-1:-1;1808:38:2;;543:331;599:9;;630:6;626:67;;-1:-1:-1;660:18:2;;-1:-1:-1;660:18:2;652:30;;626:67;712:5;;;716:1;712;:5;:1;732:5;;;;;:10;728:140;;-1:-1:-1;766:26:2;;-1:-1:-1;794:1:2;;-1:-1:-1;758:38:2;;728:140;835:18;;-1:-1:-1;855:1:2;-1:-1:-1;827:30:2;;964:209;1020:9;;1051:6;1047:75;;-1:-1:-1;1081:26:2;;-1:-1:-1;1109:1:2;1073:38;;1047:75;1140:18;1164:1;1160;:5;;;;;;1132:34;;;;964:209;;;;;:::o;12085:154:9:-;12166:4;12197:12;12190:5;12182:28;;;;-1:-1:-1;;;12182:28:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;12182:28:9;;12231:1;12227;:5;;;;;;;12085:154;-1:-1:-1;;;;12085:154:9:o;337:57050:3:-;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;