Contract 0x82Ea6f7bf853A199AB921137B119B6D41F08038e 1

/**
 *Submitted for verification at snowtrace.io on 2021-11-06
*/

// SPDX-License-Identifier: UNLICENSED

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 sec
     * @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 sec (as a percentage, and scaled by 1e18)
     */
    function getBorrowRate(
        uint256 cash,
        uint256 borrows,
        uint256 reserves
    ) external view returns (uint256);

    /**
     * @notice Calculates the current supply interest rate per sec
     * @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 sec (as a percentage, and scaled by 1e18)
     */
    function getSupplyRate(
        uint256 cash,
        uint256 borrows,
        uint256 reserves,
        uint256 reserveFactorMantissa
    ) external view returns (uint256);
}





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


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

    event NewInterestParams(
        uint256 baseRatePerSecond,
        uint256 multiplierPerSecond,
        uint256 jumpMultiplierPerSecond,
        uint256 kink1,
        uint256 kink2,
        uint256 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 seconds per year that is assumed by the interest rate model
     */
    uint256 public constant secondsPerYear = 31536000;

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

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

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

    /**
     * @notice The multiplierPerSecond after hitting a specified utilization point
     */
    uint256 public jumpMultiplierPerSecond;

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

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

    /**
     * @notice The utilization point at which the rate is fixed
     */
    uint256 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 multiplierPerSecond 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(
        uint256 baseRatePerYear,
        uint256 multiplierPerYear,
        uint256 jumpMultiplierPerYear,
        uint256 kink1_,
        uint256 kink2_,
        uint256 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 multiplierPerSecond 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(
        uint256 baseRatePerYear,
        uint256 multiplierPerYear,
        uint256 jumpMultiplierPerYear,
        uint256 kink1_,
        uint256 kink2_,
        uint256 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(
        uint256 cash,
        uint256 borrows,
        uint256 reserves
    ) public view returns (uint256) {
        // Utilization rate is 0 when there are no borrows
        if (borrows == 0) {
            return 0;
        }

        uint256 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 second, 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 second as a mantissa (scaled by 1e18)
     */
    function getBorrowRate(
        uint256 cash,
        uint256 borrows,
        uint256 reserves
    ) public view returns (uint256) {
        uint256 util = utilizationRate(cash, borrows, reserves);

        if (util <= kink1) {
            return util.mul(multiplierPerSecond).div(1e18).add(baseRatePerSecond);
        } else if (util <= kink2) {
            return kink1.mul(multiplierPerSecond).div(1e18).add(baseRatePerSecond);
        } else {
            uint256 normalRate = kink1.mul(multiplierPerSecond).div(1e18).add(baseRatePerSecond);
            uint256 excessUtil = util.sub(kink2);
            return excessUtil.mul(jumpMultiplierPerSecond).div(1e18).add(normalRate);
        }
    }

    /**
     * @notice Calculates the current supply rate per second
     * @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 second as a mantissa (scaled by 1e18)
     */
    function getSupplyRate(
        uint256 cash,
        uint256 borrows,
        uint256 reserves,
        uint256 reserveFactorMantissa
    ) public view returns (uint256) {
        uint256 oneMinusReserveFactor = uint256(1e18).sub(reserveFactorMantissa);
        uint256 borrowRate = getBorrowRate(cash, borrows, reserves);
        uint256 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 multiplierPerSecond 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(
        uint256 baseRatePerYear,
        uint256 multiplierPerYear,
        uint256 jumpMultiplierPerYear,
        uint256 kink1_,
        uint256 kink2_,
        uint256 roof_
    ) internal {
        require(kink1_ <= kink2_, "kink1 must less than or equal to kink2");
        require(roof_ >= minRoofValue, "invalid roof value");

        baseRatePerSecond = baseRatePerYear.div(secondsPerYear);
        multiplierPerSecond = (multiplierPerYear.mul(1e18)).div(secondsPerYear.mul(kink1_));
        jumpMultiplierPerSecond = jumpMultiplierPerYear.div(secondsPerYear);
        kink1 = kink1_;
        kink2 = kink2_;
        roof = roof_;

        emit NewInterestParams(baseRatePerSecond, multiplierPerSecond, jumpMultiplierPerSecond, kink1, kink2, roof);
    }
}

[{"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":"baseRatePerSecond","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"multiplierPerSecond","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"jumpMultiplierPerSecond","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":"baseRatePerSecond","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":"jumpMultiplierPerSecond","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":"multiplierPerSecond","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":true,"inputs":[],"name":"secondsPerYear","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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

8330:8255:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;8330:8255:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;13465:714;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;13465:714:0;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;280:47;;;:::i;:::-;;;;;;;;;;;;;;;;;;8923:49;;;:::i;9237:34::-;;;:::i;9796:20::-;;;:::i;9908:19::-;;;:::i;12579:496::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;12579:496:0;;;;;;;;;;;;:::i;9532:38::-;;;:::i;8774:20::-;;;:::i;:::-;;;;-1:-1:-1;;;;;8774:20:0;;;;;;;;;;;;;;11745:444;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;11745:444:0;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;14604:500;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;14604:500:0;;;;;;;;;;;;;;;;;:::i;9671:20::-;;;:::i;9389:32::-;;;:::i;13465:714::-;13592:7;13612:12;13627:40;13643:4;13649:7;13658:8;13627:15;:40::i;:::-;13612:55;;13692:5;;13684:4;:13;13680:492;;13721:62;13765:17;;13721:39;13755:4;13721:29;13730:19;;13721:4;:8;;:29;;;;:::i;:::-;:33;:39;:33;:39;:::i;:::-;:43;:62;:43;:62;:::i;:::-;13714:69;;;;;13680:492;13813:5;;13805:4;:13;13801:371;;13842:63;13887:17;;13842:40;13877:4;13842:30;13852:19;;13842:5;;:9;;:30;;;;:::i;13801:371::-;13938:18;13959:63;14004:17;;13959:40;13994:4;13959:30;13969:19;;13959:5;;:9;;:30;;;;:::i;:63::-;13938:84;;14037:18;14058:15;14067:5;;14058:4;:8;;:15;;;;:::i;:::-;14037:36;;14095:65;14149:10;14095:49;14139:4;14095:39;14110:23;;14095:10;:14;;:39;;;;:::i;:65::-;14088:72;;;;;13465:714;;;;;;:::o;280:47::-;323:4;280:47;:::o;8923:49::-;8964:8;8923:49;:::o;9237:34::-;;;;:::o;9796:20::-;;;;:::o;9908:19::-;;;;:::o;12579:496::-;12708:7;12792:12;12788:53;;-1:-1:-1;12828:1:0;12821:8;;12788:53;12853:12;12868:54;12890:31;12912:8;12890:17;:4;12899:7;12890:17;:8;:17;:::i;:::-;:21;:31;:21;:31;:::i;:::-;12868:17;:7;12880:4;12868:17;:11;:17;:::i;:54::-;12853:69;;13002:4;;12995;:11;12991:55;;;-1:-1:-1;13030:4:0;;12991:55;13063:4;12579:496;-1:-1:-1;;;;12579:496:0:o;9532:38::-;;;;:::o;8774:20::-;;;-1:-1:-1;;;;;8774:20:0;;:::o;11745:444::-;12009:5;;-1:-1:-1;;;;;12009:5:0;11995:10;:19;11987:70;;;;-1:-1:-1;;;11987:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12070:111;12100:15;12117:17;12136:21;12159:6;12167;12175:5;12070:29;:111::i;:::-;11745:444;;;;;;:::o;14604:500::-;14771:7;;14823:40;14831:4;14841:21;14823:40;:17;:40;:::i;:::-;14791:72;;14874:18;14895:38;14909:4;14915:7;14924:8;14895:13;:38::i;:::-;14874:59;-1:-1:-1;14944:18:0;14965:47;15007:4;14965:37;14874:59;14980:21;14965:37;:14;:37;:::i;:47::-;14944:68;;15030:66;15091:4;15030:56;15075:10;15030:40;15046:4;15052:7;15061:8;15030:15;:40::i;:::-;:44;:56;:44;:56;:::i;:66::-;15023:73;14604:500;-1:-1:-1;;;;;;;;14604:500:0:o;9671:20::-;;;;:::o;9389:32::-;;;;:::o;4276:471::-;4334:7;4579:6;4575:47;;-1:-1:-1;4609:1:0;4602:8;;4575:47;4646:5;;;4650:1;4646;:5;:1;4670:5;;;;;:10;4662:56;;;;-1:-1:-1;;;4662:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4738:1;-1:-1:-1;4276:471:0;;;;;:::o;5968:132::-;6026:7;6053:39;6057:1;6060;6053:39;;;;;;;;;;;;;;;;;:3;:39::i;2454:181::-;2512:7;2544:5;;;2568:6;;;;2560:46;;;;;-1:-1:-1;;;2560:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;3381:137;3439:7;3466:44;3470:1;3473;3466:44;;;;;;;;;;;;;;;;;:3;:44::i;15761:821::-;16029:6;16019;:16;;16011:67;;;;-1:-1:-1;;;16011:67:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9113:4;16097:5;:21;;16089:52;;;;;-1:-1:-1;;;16089:52:0;;;;;;;;;;;;-1:-1:-1;;;16089:52:0;;;;;;;;;;;;;;;16174:35;:15;8964:8;16174:35;:19;:35;:::i;:::-;16154:17;:55;16242:61;16276:26;8964:8;16295:6;16276:26;:18;:26;:::i;:::-;16243:27;:17;16265:4;16243:27;:21;:27;:::i;16242:61::-;16220:19;:83;16340:41;:21;8964:8;16340:41;:25;:41;:::i;:::-;16314:23;:67;;;16392:5;:14;;;16417:5;:14;;;16442:4;:12;;;16490:17;;16509:19;;16472:102;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15761:821;;;;;;:::o;6588:379::-;6708:7;6810:12;6803:5;6795:28;;;;-1:-1:-1;;;6795:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;23:1:-1;8:100;33:3;30:1;27:10;8:100;;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;;12:14;6795:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6834:9;6850:1;6846;:5;;;;;;;6588:379;-1:-1:-1;;;;;6588:379:0:o;3807:226::-;3927:7;3963:12;3955:6;;;;3947:29;;;;-1:-1:-1;;;3947:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;3947:29:0;-1:-1:-1;;;3999:5:0;;;3807:226::o

bzzr://16e07e1a1051e4f8f17a61e118f7601ecdd21d4f995ad9fd27eae59ea7fab3b4