Contract 0x47db169cff785286966ca2acc90a8395a7366490

/**
 *Submitted for verification at cronoscan.com on 2022-01-12
*/

// Sources flattened with hardhat v2.6.4 https://hardhat.org

// File contracts/SafeMath.sol

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


// File contracts/InterestModels/BaseJumpRateModelV2.sol

pragma solidity ^0.5.16;

contract BaseJumpRateModelV2 {
    using SafeMath for uint;

    event NewInterestParams(uint baseRatePerBlock, uint multiplierPerBlock, uint jumpMultiplierPerBlock, uint kink);

    /**
     * @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 = 5256000;

    /**
     * @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 jump multiplier is applied
     */
    uint public kink;

    /**
     * @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 kink_ The utilization point at which the jump multiplier is applied
     * @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 kink_, address owner_) internal {
        owner = owner_;

        updateJumpRateModelInternal(baseRatePerYear,  multiplierPerYear, jumpMultiplierPerYear, kink_);
    }

    /**
     * @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 kink_ The utilization point at which the jump multiplier is applied
     */
    function updateJumpRateModel(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) external {
        require(msg.sender == owner, "only the owner may call this function.");

        updateJumpRateModelInternal(baseRatePerYear, multiplierPerYear, jumpMultiplierPerYear, kink_);
    }

    /**
     * @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 pure returns (uint) {
        // Utilization rate is 0 when there are no borrows
        if (borrows == 0) {
            return 0;
        }

        return borrows.mul(1e18).div(cash.add(borrows).sub(reserves));
    }

    /**
     * @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 getBorrowRateInternal(uint cash, uint borrows, uint reserves) internal view returns (uint) {
        uint util = utilizationRate(cash, borrows, reserves);

        if (util <= kink) {
            return util.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
        } else {
            uint normalRate = kink.mul(multiplierPerBlock).div(1e18).add(baseRatePerBlock);
            uint excessUtil = util.sub(kink);
            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 = getBorrowRateInternal(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 kink_ The utilization point at which the jump multiplier is applied
     */
    function updateJumpRateModelInternal(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_) internal {
        baseRatePerBlock = baseRatePerYear.div(blocksPerYear);
        multiplierPerBlock = (multiplierPerYear.mul(1e18)).div(blocksPerYear.mul(kink_));
        jumpMultiplierPerBlock = jumpMultiplierPerYear.div(blocksPerYear);
        kink = kink_;

        emit NewInterestParams(baseRatePerBlock, multiplierPerBlock, jumpMultiplierPerBlock, kink);
    }
}


// File contracts/InterestModels/InterestRateModel.sol

pragma solidity ^0.5.16;

/**
  * @title Tectonic's InterestRateModel Interface
  * @author Tectonic
  */
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 amount 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 amount of reserves the market has
      * @param reserveFactorMantissa The current reserve factor the market has
      * @return The supply rate per block (as a percentage, and scaled by 1e18)
      */
    function getSupplyRate(uint cash, uint borrows, uint reserves, uint reserveFactorMantissa) external view returns (uint);

}


// File contracts/InterestModels/JumpRateModelV2.sol

pragma solidity ^0.5.16;


/**
  * @title Tectonic's JumpRateModel Contract V2 for V2 tTokens
  * @author Arr00
  * @notice Supports only for V2 tTokens
  */
contract JumpRateModelV2 is InterestRateModel, BaseJumpRateModelV2  {

	/**
     * @notice Calculates the current borrow 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
     * @return The borrow rate percentage per block as a mantissa (scaled by 1e18)
     */
    function getBorrowRate(uint cash, uint borrows, uint reserves) external view returns (uint) {
        return getBorrowRateInternal(cash, borrows, reserves);
    }

    constructor(uint baseRatePerYear, uint multiplierPerYear, uint jumpMultiplierPerYear, uint kink_, address owner_) 
    	BaseJumpRateModelV2(baseRatePerYear,multiplierPerYear,jumpMultiplierPerYear,kink_,owner_) public {}
}

[{"inputs":[{"internalType":"uint256","name":"baseRatePerYear","type":"uint256"},{"internalType":"uint256","name":"multiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"jumpMultiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"kink_","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":"kink","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":"kink","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":false,"inputs":[{"internalType":"uint256","name":"baseRatePerYear","type":"uint256"},{"internalType":"uint256","name":"multiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"jumpMultiplierPerYear","type":"uint256"},{"internalType":"uint256","name":"kink_","type":"uint256"}],"name":"updateJumpRateModel","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":"pure","type":"function"}]

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

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b1a2bc2ec5000000000000000000000000000000000000000000000000000006f05b59d3b200000000000000000000000000000000000000000000000000000bcbce7f1b15000000000000000000000000000000000957896fcb916bacccfdb55caecfaecfb587

-----Decoded View---------------
Arg [0] : baseRatePerYear (uint256): 0
Arg [1] : multiplierPerYear (uint256): 50000000000000000
Arg [2] : jumpMultiplierPerYear (uint256): 500000000000000000
Arg [3] : kink_ (uint256): 850000000000000000
Arg [4] : owner_ (address): 0x00000957896fcb916bacccfdb55caecfaecfb587

-----Encoded View---------------
5 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [1] : 00000000000000000000000000000000000000000000000000b1a2bc2ec50000
Arg [2] : 00000000000000000000000000000000000000000000000006f05b59d3b20000
Arg [3] : 0000000000000000000000000000000000000000000000000bcbce7f1b150000
Arg [4] : 00000000000000000000000000000957896fcb916bacccfdb55caecfaecfb587

14663:805:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;14663:805:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15073:164;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;15073:164:0;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;9225:319;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;9225:319:0;;;;;;;;;;;;;;;;;:::i;:::-;;13314:47;;;:::i;:::-;;;;;;;;;;;;;;;;;;9934:297;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;9934:297:0;;;;;;;;;;;;:::i;7413:30::-;;;:::i;7101:20::-;;;:::i;:::-;;;;-1:-1:-1;;;;;7101:20:0;;;;;;;;;;;;;;7249:44;;;:::i;11581:438::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;11581:438:0;;;;;;;;;;;;;;;;;:::i;7699:34::-;;;:::i;7561:28::-;;;:::i;7838:16::-;;;:::i;15073:164::-;15159:4;15183:46;15205:4;15211:7;15220:8;15183:21;:46::i;:::-;15176:53;;15073:164;;;;;;:::o;9225:319::-;9382:5;;-1:-1:-1;;;;;9382:5:0;9368:10;:19;9360:70;;;;-1:-1:-1;;;9360:70:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9443:93;9471:15;9488:17;9507:21;9530:5;9443:27;:93::i;:::-;9225:319;;;;:::o;13314:47::-;13357:4;13314:47;:::o;9934:297::-;10020:4;10101:12;10097:53;;-1:-1:-1;10137:1:0;10130:8;;10097:53;10169:54;10191:31;10213:8;10191:17;:4;10200:7;10191:17;:8;:17;:::i;:::-;:21;:31;:21;:31;:::i;:::-;10169:17;:7;10181:4;10169:17;:11;:17;:::i;:::-;:21;:54;:21;:54;:::i;7413:30::-;;;;:::o;7101:20::-;;;-1:-1:-1;;;;;7101:20:0;;:::o;7249:44::-;7286:7;7249:44;:::o;11581:438::-;11693:4;;11739:37;11744:4;11754:21;11739:37;:14;:37;:::i;:::-;11710:66;;11787:15;11805:46;11827:4;11833:7;11842:8;11805:21;:46::i;:::-;11787:64;-1:-1:-1;11862:15:0;11880:47;11922:4;11880:37;11787:64;11895:21;11880:37;:14;:37;:::i;:47::-;11862:65;;11945:66;12006:4;11945:56;11990:10;11945:40;11961:4;11967:7;11976:8;11945:15;:40::i;:::-;:44;:56;:44;:56;:::i;:66::-;11938:73;11581:438;-1:-1:-1;;;;;;;;11581:438:0:o;7699:34::-;;;;:::o;7561:28::-;;;;:::o;7838:16::-;;;;:::o;10619:539::-;10713:4;10730:9;10742:40;10758:4;10764:7;10773:8;10742:15;:40::i;:::-;10730:52;;10807:4;;10799;:12;10795:356;;10835:60;10878:16;;10835:38;10868:4;10835:28;10844:18;;10835:4;:8;;:28;;;;:::i;:38::-;:42;:60;:42;:60;:::i;:::-;10828:67;;;;;10795:356;10928:15;10946:60;10989:16;;10946:38;10979:4;10946:28;10955:18;;10946:4;;:8;;:28;;;;:::i;:60::-;10928:78;;11021:15;11039:14;11048:4;;11039;:8;;:14;;;;:::i;:::-;11021:32;;11075:64;11128:10;11075:48;11118:4;11075:38;11090:22;;11075:10;:14;;:38;;;;:::i;:64::-;11068:71;;;;;;;12517:497;12679:34;:15;7286:7;12679:34;:19;:34;:::i;:::-;12660:16;:53;12745:59;12779:24;7286:7;12797:5;12779:24;:17;:24;:::i;12745:59::-;12724:18;:80;12840:40;:21;7286:7;12840:40;:25;:40;:::i;:::-;12815:22;:65;;;12891:4;:12;;;12939:16;;12957:18;;12921:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;12517:497;;;;:::o;1084:181::-;1142:7;1174:5;;;1198:6;;;;1190:46;;;;;-1:-1:-1;;;1190:46:0;;;;;;;;;;;;-1:-1:-1;;;1190:46:0;;;;;;;;;;;;;;;1256:1;-1:-1:-1;1084:181:0;;;;;:::o;1977:137::-;2035:7;2062:44;2066:1;2069;2062:44;;;;;;;;;;;;;;;;;:3;:44::i;2838:471::-;2896:7;3141:6;3137:47;;-1:-1:-1;3171:1:0;3164:8;;3137:47;3208:5;;;3212:1;3208;:5;:1;3232:5;;;;;:10;3224:56;;;;-1:-1:-1;;;3224:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4496:132;4554:7;4581:39;4585:1;4588;4581:39;;;;;;;;;;;;;-1:-1:-1;;;4581:39:0;;;:3;:39::i;2403:192::-;2489:7;2525:12;2517:6;;;;2509:29;;;;-1:-1:-1;;;2509:29: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;2509:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2561:5:0;;;2403:192::o;5116:345::-;5202:7;5304:12;5297:5;5289:28;;;;-1:-1:-1;;;5289:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;5289:28:0;;5328:9;5344:1;5340;:5;;;;;;;5116:345;-1:-1:-1;;;;;5116:345:0:o

bzzr://02f7b0677192c2471895d8f68cc9469c6f9888d1be139dcaae1b19dda68341d1