Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

pragma solidity ^0.5.16;

import "./InterestRateModel.sol";
import "./SafeMath.sol";

/**
  * @title CREAM's TripleSlopeRateModel Contract
  * @author C.R.E.A.M. Finance
  */
contract TripleSlopeRateModel is InterestRateModel {
    using SafeMath for uint;

    event NewInterestParams(uint baseRatePerBlock, uint multiplierPerBlock, uint jumpMultiplierPerBlock, uint kink1, uint kink2, uint roof);

    /**
     * @notice The address of the owner, i.e. the Timelock contract, which can update parameters directly
     */
    address public owner;

    /**
     * @notice The approximate number of blocks per year that is assumed by the interest rate model
     */
    uint public constant blocksPerYear = 2102400;

    /**
     * @notice The minimum roof value used for calculating borrow rate.
     */
    uint internal constant minRoofValue = 1e18;

    /**
     * @notice The multiplier of utilization rate that gives the slope of the interest rate
     */
    uint public multiplierPerBlock;

    /**
     * @notice The base interest rate which is the y-intercept when utilization rate is 0
     */
    uint public baseRatePerBlock;

    /**
     * @notice The multiplierPerBlock after hitting a specified utilization point
     */
    uint public jumpMultiplierPerBlock;

    /**
     * @notice The utilization point at which the interest rate is fixed
     */
    uint public kink1;

    /**
     * @notice The utilization point at which the jump multiplier is applied
     */
    uint public kink2;

    /**
     * @notice The utilization point at which the rate is fixed
     */
    uint public roof;

    /**
     * @notice Construct an interest rate model
     * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by 1e18)
     * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by 1e18)
     * @param jumpMultiplierPerYear The multiplierPerBlock after hitting a specified utilization point
     * @param kink1_ The utilization point at which the interest rate is fixed
     * @param kink2_ The utilization point at which the jump multiplier is applied
     * @param roof_ The utilization point at which the borrow rate is fixed
     * @param owner_ The address of the owner, i.e. the Timelock contract (which has the ability to update parameters directly)
     */
    constructor(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink1_, uint kink2_, uint roof_, address owner_) public {
        owner = owner_;

        updateTripleRateModelInternal(baseRatePerYear,  multiplierPerYear, jumpMultiplierPerYear, kink1_, kink2_, roof_);
    }

    /**
     * @notice Update the parameters of the interest rate model (only callable by owner, i.e. Timelock)
     * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by 1e18)
     * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by 1e18)
     * @param jumpMultiplierPerYear The multiplierPerBlock after hitting a specified utilization point
     * @param kink1_ The utilization point at which the interest rate is fixed
     * @param kink2_ The utilization point at which the jump multiplier is applied
     * @param roof_ The utilization point at which the borrow rate is fixed
     */
    function updateTripleRateModel(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink1_, uint kink2_, uint roof_) external {
        require(msg.sender == owner, "only the owner may call this function.");

        updateTripleRateModelInternal(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink1_, kink2_, roof_);
    }

    /**
     * @notice Calculates the utilization rate of the market: `borrows / (cash + borrows - reserves)`
     * @param cash The amount of cash in the market
     * @param borrows The amount of borrows in the market
     * @param reserves The amount of reserves in the market (currently unused)
     * @return The utilization rate as a mantissa between [0, 1e18]
     */
    function utilizationRate(uint cash, uint borrows, uint reserves) public view returns (uint) {
        // Utilization rate is 0 when there are no borrows
        if (borrows == 0) {
            return 0;
        }

        uint util = borrows.mul(1e18).div(cash.add(borrows).sub(reserves));
        // If the utilization is above the roof, cap it.
        if (util > roof) {
            util = roof;
        }
        return util;
    }

    /**
     * @notice Calculates the current borrow rate per block, with the error code expected by the market
     * @param cash The amount of cash in the market
     * @param borrows The amount of borrows in the market
     * @param reserves The amount of reserves in the market
     * @return The borrow rate percentage per block as a mantissa (scaled by 1e18)
     */
    function getBorrowRate(uint cash, uint borrows, uint reserves) public view returns (uint) {
        uint util = utilizationRate(cash, borrows, reserves);

        if (util <= kink1) {
            return util.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
        } else if (util <= kink2) {
            return kink1.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
        } else {
            uint normalRate = kink1.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
            uint excessUtil = util.sub(kink2);
            return excessUtil.mul(jumpMultiplierPerBlock).div(1e18).add(normalRate);
        }
    }

    /**
     * @notice Calculates the current supply rate per block
     * @param cash The amount of cash in the market
     * @param borrows The amount of borrows in the market
     * @param reserves The amount of reserves in the market
     * @param reserveFactorMantissa The current reserve factor for the market
     * @return The supply rate percentage per block as a mantissa (scaled by 1e18)
     */
    function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) public view returns (uint) {
        uint oneMinusReserveFactor = uint(1e18).sub(reserveFactorMantissa);
        uint borrowRate = getBorrowRate(cash, borrows, reserves);
        uint rateToPool = borrowRate.mul(oneMinusReserveFactor).div(1e18);
        return utilizationRate(cash, borrows, reserves).mul(rateToPool).div(1e18);
    }

    /**
     * @notice Internal function to update the parameters of the interest rate model
     * @param baseRatePerYear The approximate target base APR, as a mantissa (scaled by 1e18)
     * @param multiplierPerYear The rate of increase in interest rate wrt utilization (scaled by 1e18)
     * @param jumpMultiplierPerYear The multiplierPerBlock after hitting a specified utilization point
     * @param kink1_ The utilization point at which the interest rate is fixed
     * @param kink2_ The utilization point at which the jump multiplier is applied
     * @param roof_ The utilization point at which the borrow rate is fixed
     */
    function updateTripleRateModelInternal(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink1_, uint kink2_, uint roof_) internal {
        require(kink1_ <= kink2_, "kink1 must less than or equal to kink2");
        require(roof_ >= minRoofValue, "invalid roof value");

        baseRatePerBlock = baseRatePerYear.div(blocksPerYear);
        multiplierPerBlock = (multiplierPerYear.mul(1e18)).div(blocksPerYear.mul(kink1_));
        jumpMultiplierPerBlock = jumpMultiplierPerYear.div(blocksPerYear);
        kink1 = kink1_;
        kink2 = kink2_;
        roof = roof_;

        emit NewInterestParams(baseRatePerBlock, multiplierPerBlock, jumpMultiplierPerBlock, kink1, kink2, roof);
    }
}

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;

// From https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/math/Math.sol
// Subject to the MIT license.

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting with custom message on overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, errorMessage);

        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction underflow");
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on underflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     * - Subtraction cannot underflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, errorMessage);

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers.
     * Reverts on division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    /**
     * @dev Returns the integer division of two unsigned integers.
     * Reverts with custom message on division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return mod(a, b, "SafeMath: modulo by zero");
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * Reverts with custom message when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b != 0, errorMessage);
        return a % b;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"uint256","name":"baseRatePerYear","type":"uint256"},{"internalType":"uint256","name":"multiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"jumpMultiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"kink1_","type":"uint256"},{"internalType":"uint256","name":"kink2_","type":"uint256"},{"internalType":"uint256","name":"roof_","type":"uint256"},{"internalType":"address","name":"owner_","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"baseRatePerBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"multiplierPerBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"jumpMultiplierPerBlock","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"kink1","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"kink2","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"roof","type":"uint256"}],"name":"NewInterestParams","type":"event"},{"constant":true,"inputs":[],"name":"baseRatePerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"blocksPerYear","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"cash","type":"uint256"},{"internalType":"uint256","name":"borrows","type":"uint256"},{"internalType":"uint256","name":"reserves","type":"uint256"}],"name":"getBorrowRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"cash","type":"uint256"},{"internalType":"uint256","name":"borrows","type":"uint256"},{"internalType":"uint256","name":"reserves","type":"uint256"},{"internalType":"uint256","name":"reserveFactorMantissa","type":"uint256"}],"name":"getSupplyRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isInterestRateModel","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"jumpMultiplierPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"kink1","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"kink2","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"multiplierPerBlock","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"roof","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"baseRatePerYear","type":"uint256"},{"internalType":"uint256","name":"multiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"jumpMultiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"kink1_","type":"uint256"},{"internalType":"uint256","name":"kink2_","type":"uint256"},{"internalType":"uint256","name":"roof_","type":"uint256"}],"name":"updateTripleRateModel","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"cash","type":"uint256"},{"internalType":"uint256","name":"borrows","type":"uint256"},{"internalType":"uint256","name":"reserves","type":"uint256"}],"name":"utilizationRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"}]

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

175:7537:2:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;175:7537:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4866:640;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4866:640:2;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;225:47:0;;;:::i;:::-;;;;;;;;;;;;;;;;;;1488:17:2;;;:::i;1592:16::-;;;:::i;4052:435::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;4052:435:2;;;;;;;;;;;;:::i;965:30::-;;;:::i;526:20::-;;;:::i;:::-;;;;-1:-1:-1;;;;;526:20:2;;;;;;;;;;;;;;669:44;;;:::i;3310:361::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;3310:361:2;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;5919:425;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;5919:425:2;;;;;;;;;;;;;;;;;:::i;1241:34::-;;;:::i;1371:17::-;;;:::i;1108:28::-;;;:::i;4866:640::-;4950:4;4966:9;4978:40;4994:4;5000:7;5009:8;4978:15;:40::i;:::-;4966:52;;5041:5;;5033:4;:13;5029:471;;5069:60;5112:16;;5069:38;5102:4;5069:28;5078:18;;5069:4;:8;;:28;;;;:::i;:::-;:32;:38;:32;:38;:::i;:::-;:42;:60;:42;:60;:::i;:::-;5062:67;;;;;5029:471;5158:5;;5150:4;:13;5146:354;;5186:61;5230:16;;5186:39;5220:4;5186:29;5196:18;;5186:5;;:9;;:29;;;;:::i;5146:354::-;5278:15;5296:61;5340:16;;5296:39;5330:4;5296:29;5306:18;;5296:5;;:9;;:29;;;;:::i;:61::-;5278:79;;5371:15;5389;5398:5;;5389:4;:8;;:15;;;;:::i;:::-;5371:33;;5425:64;5478:10;5425:48;5468:4;5425:38;5440:22;;5425:10;:14;;:38;;;;:::i;:64::-;5418:71;;;;;4866:640;;;;;;:::o;225:47:0:-;268:4;225:47;:::o;1488:17:2:-;;;;:::o;1592:16::-;;;;:::o;4052:435::-;4138:4;4217:12;4213:51;;-1:-1:-1;4252:1:2;4245:8;;4213:51;4274:9;4286:54;4308:31;4330:8;4308:17;:4;4317:7;4308:17;:8;:17;:::i;:::-;:21;:31;:21;:31;:::i;:::-;4286:17;:7;4298:4;4286:17;:11;:17;:::i;:54::-;4274:66;;4418:4;;4411;:11;4407:53;;;-1:-1:-1;4445:4:2;;4407:53;4476:4;4052:435;-1:-1:-1;;;;4052:435:2:o;965:30::-;;;;:::o;526:20::-;;;-1:-1:-1;;;;;526:20:2;;:::o;669:44::-;706:7;669:44;:::o;3310:361::-;3494:5;;-1:-1:-1;;;;;3494:5:2;3480:10;:19;3472:70;;;;-1:-1:-1;;;3472:70:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3553:111;3583:15;3600:17;3619:21;3642:6;3650;3658:5;3553:29;:111::i;:::-;3310:361;;;;;;:::o;5919:425::-;6031:4;;6076:37;6081:4;6091:21;6076:37;:14;:37;:::i;:::-;6047:66;;6123:15;6141:38;6155:4;6161:7;6170:8;6141:13;:38::i;:::-;6123:56;-1:-1:-1;6189:15:2;6207:47;6249:4;6207:37;6123:56;6222:21;6207:37;:14;:37;:::i;:47::-;6189:65;;6271:66;6332:4;6271:56;6316:10;6271:40;6287:4;6293:7;6302:8;6271:15;:40::i;:::-;:44;:56;:44;:56;:::i;:66::-;6264:73;5919:425;-1:-1:-1;;;;;;;;5919:425:2:o;1241:34::-;;;;:::o;1371:17::-;;;;:::o;1108:28::-;;;;:::o;2656:459:1:-;2714:7;2955:6;2951:45;;-1:-1:-1;2984:1:1;2977:8;;2951:45;3018:5;;;3022:1;3018;:5;:1;3041:5;;;;;:10;3033:56;;;;-1:-1:-1;;;3033:56:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3107:1;-1:-1:-1;2656:459:1;;;;;:::o;4267:130::-;4325:7;4351:39;4355:1;4358;4351:39;;;;;;;;;;;;;;;;;:3;:39::i;959:176::-;1017:7;1048:5;;;1071:6;;;;1063:46;;;;;-1:-1:-1;;;1063:46:1;;;;;;;;;;;;;;;;;;;;;;;;;;;1822:135;1880:7;1906:44;1910:1;1913;1906:44;;;;;;;;;;;;;;;;;:3;:44::i;6989:721:2:-;7177:6;7167;:16;;7159:67;;;;-1:-1:-1;;;7159:67:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;846:4;7244:5;:21;;7236:52;;;;;-1:-1:-1;;;7236:52:2;;;;;;;;;;;;-1:-1:-1;;;7236:52:2;;;;;;;;;;;;;;;7318:34;:15;706:7;7318:34;:19;:34;:::i;:::-;7299:16;:53;7383:60;7417:25;706:7;7435:6;7417:25;:17;:25;:::i;:::-;7384:27;:17;7406:4;7384:27;:21;:27;:::i;7383:60::-;7362:18;:81;7478:40;:21;706:7;7478:40;:25;:40;:::i;:::-;7453:22;:65;;;7528:5;:14;;;7552:5;:14;;;7576:4;:12;;;7622:16;;7640:18;;7604:99;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6989:721;;;;;;:::o;4872:338:1:-;4958:7;5058:12;5051:5;5043:28;;;;-1:-1:-1;;;5043:28:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;5043:28:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5081:9;5097:1;5093;:5;;;;;;;4872:338;-1:-1:-1;;;;;4872:338:1:o;2236:187::-;2322:7;2357:12;2349:6;;;;2341:29;;;;-1:-1:-1;;;2341:29:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;2341:29:1;-1:-1:-1;;;2392:5:1;;;2236:187::o

bzzr://11013ad81438863f114b7118026a0baf3c10cba2a315d8c3813c0d9b2b783bf0