Token Tarot Borrowable

Overview ERC-20

Price

$0.00 @ 0.000000 FTM

Fully Diluted Market Cap

Total Supply:

0 bTAROT

Holders:

917 addresses

Contract:

0x7623abcb2a3da6bb14bbb713b58c9b11fc9713b1

Decimals:

Social Profiles:

Not Available, Update ?

Filtered by Token Holder

0x4cb93eb88cfc55f364e9300254003d34c28cac9d

Balance

0.000000000000010971 bTAROT

Value

$0.00

0x4cb93eb88cfc55f364e9300254003d34c28cac9d

[ Download CSV Export ]

Click here to update the token ICO / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Similar Match Source Code
Note: This contract matches the deployed ByteCode of the Source Code for Contract 0x31c43ab4827c4ec0e5377db6a22fe83d3c415da1

Contract Name:

Borrowable

Compiler Version

v0.5.16+commit.9c3226ce

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2021-09-20
*/

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

// File contracts/libraries/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/TarotERC20.sol

pragma solidity =0.5.16;

// This contract is basically UniswapV2ERC20 with small modifications
// src: https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol

contract TarotERC20 {
    using SafeMath for uint256;

    string public name;
    string public symbol;
    uint8 public decimals = 18;
    uint256 public totalSupply;
    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    bytes32 public DOMAIN_SEPARATOR;
    mapping(address => uint256) public nonces;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    constructor() public {}

    function _setName(string memory _name, string memory _symbol) internal {
        name = _name;
        symbol = _symbol;
        uint256 chainId;
        assembly {
            chainId := chainid
        }
        DOMAIN_SEPARATOR = keccak256(
            abi.encode(
                keccak256(
                    "EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
                ),
                keccak256(bytes(_name)),
                keccak256(bytes("1")),
                chainId,
                address(this)
            )
        );
    }

    function _mint(address to, uint256 value) internal {
        totalSupply = totalSupply.add(value);
        balanceOf[to] = balanceOf[to].add(value);
        emit Transfer(address(0), to, value);
    }

    function _burn(address from, uint256 value) internal {
        balanceOf[from] = balanceOf[from].sub(value);
        totalSupply = totalSupply.sub(value);
        emit Transfer(from, address(0), value);
    }

    function _approve(
        address owner,
        address spender,
        uint256 value
    ) private {
        allowance[owner][spender] = value;
        emit Approval(owner, spender, value);
    }

    function _transfer(
        address from,
        address to,
        uint256 value
    ) internal {
        balanceOf[from] = balanceOf[from].sub(
            value,
            "Tarot: TRANSFER_TOO_HIGH"
        );
        balanceOf[to] = balanceOf[to].add(value);
        emit Transfer(from, to, value);
    }

    function approve(address spender, uint256 value) external returns (bool) {
        _approve(msg.sender, spender, value);
        return true;
    }

    function transfer(address to, uint256 value) external returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool) {
        if (allowance[from][msg.sender] != uint256(-1)) {
            allowance[from][msg.sender] = allowance[from][msg.sender].sub(
                value,
                "Tarot: TRANSFER_NOT_ALLOWED"
            );
        }
        _transfer(from, to, value);
        return true;
    }

    function _checkSignature(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s,
        bytes32 typehash
    ) internal {
        require(deadline >= block.timestamp, "Tarot: EXPIRED");
        bytes32 digest =
            keccak256(
                abi.encodePacked(
                    "\x19\x01",
                    DOMAIN_SEPARATOR,
                    keccak256(
                        abi.encode(
                            typehash,
                            owner,
                            spender,
                            value,
                            nonces[owner]++,
                            deadline
                        )
                    )
                )
            );
        address recoveredAddress = ecrecover(digest, v, r, s);
        require(
            recoveredAddress != address(0) && recoveredAddress == owner,
            "Tarot: INVALID_SIGNATURE"
        );
    }

    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 public constant PERMIT_TYPEHASH =
        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        _checkSignature(
            owner,
            spender,
            value,
            deadline,
            v,
            r,
            s,
            PERMIT_TYPEHASH
        );
        _approve(owner, spender, value);
    }
}


// File contracts/interfaces/IERC20.sol

pragma solidity >=0.5.0;

interface IERC20 {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function decimals() external view returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);
}


// File contracts/interfaces/IPoolToken.sol

pragma solidity >=0.5.0;

interface IPoolToken {
    /*** Tarot ERC20 ***/

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /*** Pool Token ***/

    event Mint(
        address indexed sender,
        address indexed minter,
        uint256 mintAmount,
        uint256 mintTokens
    );
    event Redeem(
        address indexed sender,
        address indexed redeemer,
        uint256 redeemAmount,
        uint256 redeemTokens
    );
    event Sync(uint256 totalBalance);

    function underlying() external view returns (address);

    function factory() external view returns (address);

    function totalBalance() external view returns (uint256);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function exchangeRate() external returns (uint256);

    function mint(address minter) external returns (uint256 mintTokens);

    function redeem(address redeemer) external returns (uint256 redeemAmount);

    function skim(address to) external;

    function sync() external;

    function _setFactory() external;
}


// File contracts/PoolToken.sol

pragma solidity =0.5.16;




contract PoolToken is IPoolToken, TarotERC20 {
    uint256 internal constant initialExchangeRate = 1e18;
    address public underlying;
    address public factory;
    uint256 public totalBalance;
    uint256 public constant MINIMUM_LIQUIDITY = 1000;

    event Mint(
        address indexed sender,
        address indexed minter,
        uint256 mintAmount,
        uint256 mintTokens
    );
    event Redeem(
        address indexed sender,
        address indexed redeemer,
        uint256 redeemAmount,
        uint256 redeemTokens
    );
    event Sync(uint256 totalBalance);

    /*** Initialize ***/

    // called once by the factory
    function _setFactory() external {
        require(factory == address(0), "Tarot: FACTORY_ALREADY_SET");
        factory = msg.sender;
    }

    /*** PoolToken ***/

    function _update() internal {
        totalBalance = IERC20(underlying).balanceOf(address(this));
        emit Sync(totalBalance);
    }

    function exchangeRate() public returns (uint256) {
        uint256 _totalSupply = totalSupply; // gas savings
        uint256 _totalBalance = totalBalance; // gas savings
        if (_totalSupply == 0 || _totalBalance == 0) return initialExchangeRate;
        return _totalBalance.mul(1e18).div(_totalSupply);
    }

    // this low-level function should be called from another contract
    function mint(address minter)
        external
        nonReentrant
        update
        returns (uint256 mintTokens)
    {
        uint256 balance = IERC20(underlying).balanceOf(address(this));
        uint256 mintAmount = balance.sub(totalBalance);
        mintTokens = mintAmount.mul(1e18).div(exchangeRate());

        if (totalSupply == 0) {
            // permanently lock the first MINIMUM_LIQUIDITY tokens
            mintTokens = mintTokens.sub(MINIMUM_LIQUIDITY);
            _mint(address(0), MINIMUM_LIQUIDITY);
        }
        require(mintTokens > 0, "Tarot: MINT_AMOUNT_ZERO");
        _mint(minter, mintTokens);
        emit Mint(msg.sender, minter, mintAmount, mintTokens);
    }

    // this low-level function should be called from another contract
    function redeem(address redeemer)
        external
        nonReentrant
        update
        returns (uint256 redeemAmount)
    {
        uint256 redeemTokens = balanceOf[address(this)];
        redeemAmount = redeemTokens.mul(exchangeRate()).div(1e18);

        require(redeemAmount > 0, "Tarot: REDEEM_AMOUNT_ZERO");
        require(redeemAmount <= totalBalance, "Tarot: INSUFFICIENT_CASH");
        _burn(address(this), redeemTokens);
        _safeTransfer(redeemer, redeemAmount);
        emit Redeem(msg.sender, redeemer, redeemAmount, redeemTokens);
    }

    // force real balance to match totalBalance
    function skim(address to) external nonReentrant {
        _safeTransfer(
            to,
            IERC20(underlying).balanceOf(address(this)).sub(totalBalance)
        );
    }

    // force totalBalance to match real balance
    function sync() external nonReentrant update {}

    /*** Utilities ***/

    // same safe transfer function used by UniSwapV2 (with fixed underlying)
    bytes4 private constant SELECTOR =
        bytes4(keccak256(bytes("transfer(address,uint256)")));

    function _safeTransfer(address to, uint256 amount) internal {
        (bool success, bytes memory data) =
            underlying.call(abi.encodeWithSelector(SELECTOR, to, amount));
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "Tarot: TRANSFER_FAILED"
        );
    }

    // prevents a contract from calling itself, directly or indirectly.
    bool internal _notEntered = true;
    modifier nonReentrant() {
        require(_notEntered, "Tarot: REENTERED");
        _notEntered = false;
        _;
        _notEntered = true;
    }

    // update totalBalance with current balance
    modifier update() {
        _;
        _update();
    }
}


// File contracts/BStorage.sol

pragma solidity =0.5.16;

contract BStorage {
    address public collateral;

    mapping(address => mapping(address => uint256)) public borrowAllowance;

    struct BorrowSnapshot {
        uint112 principal; // amount in underlying when the borrow was last updated
        uint112 interestIndex; // borrow index when borrow was last updated
    }
    mapping(address => BorrowSnapshot) internal borrowBalances;

    // use one memory slot
    uint112 public borrowIndex = 1e18;
    uint112 public totalBorrows;
    uint32 public accrualTimestamp = uint32(block.timestamp % 2**32);

    uint256 public exchangeRateLast;

    // use one memory slot
    uint48 public borrowRate;
    uint48 public kinkBorrowRate = 3.1709792e9; //10% per year
    uint32 public rateUpdateTimestamp = uint32(block.timestamp % 2**32);

    uint256 public reserveFactor = 0.10e18; //10%
    uint256 public kinkUtilizationRate = 0.70e18; //70%
    uint256 public adjustSpeed = 0.5787037e12; //5% per day
    address public borrowTracker;

    function safe112(uint256 n) internal pure returns (uint112) {
        require(n < 2**112, "Tarot: SAFE112");
        return uint112(n);
    }
}


// File contracts/BAllowance.sol

pragma solidity =0.5.16;


contract BAllowance is PoolToken, BStorage {
    event BorrowApproval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    function _borrowApprove(
        address owner,
        address spender,
        uint256 value
    ) private {
        borrowAllowance[owner][spender] = value;
        emit BorrowApproval(owner, spender, value);
    }

    function borrowApprove(address spender, uint256 value)
        external
        returns (bool)
    {
        _borrowApprove(msg.sender, spender, value);
        return true;
    }

    function _checkBorrowAllowance(
        address owner,
        address spender,
        uint256 value
    ) internal {
        uint256 _borrowAllowance = borrowAllowance[owner][spender];
        if (spender != owner && _borrowAllowance != uint256(-1)) {
            require(_borrowAllowance >= value, "Tarot: BORROW_NOT_ALLOWED");
            borrowAllowance[owner][spender] = _borrowAllowance - value;
        }
    }

    // keccak256("BorrowPermit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 public constant BORROW_PERMIT_TYPEHASH =
        0xf6d86ed606f871fa1a557ac0ba607adce07767acf53f492fb215a1a4db4aea6f;

    function borrowPermit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external {
        _checkSignature(
            owner,
            spender,
            value,
            deadline,
            v,
            r,
            s,
            BORROW_PERMIT_TYPEHASH
        );
        _borrowApprove(owner, spender, value);
    }
}


// File contracts/BInterestRateModel.sol

pragma solidity =0.5.16;


contract BInterestRateModel is PoolToken, BStorage {

	// When utilization is 100% borrowRate is kinkBorrowRate * KINK_MULTIPLIER
	// kinkBorrowRate relative adjustment per second belongs to [1-adjustSpeed, 1+adjustSpeed*(KINK_MULTIPLIER-1)]
	uint public constant KINK_MULTIPLIER = 5;
	uint public constant KINK_BORROW_RATE_MAX = 31.7097920e9; //100% per year
	uint public constant KINK_BORROW_RATE_MIN = 0.31709792e9; //1% per year

	event AccrueInterest(uint interestAccumulated, uint borrowIndex, uint totalBorrows);
	event CalculateKinkBorrowRate(uint kinkBorrowRate);
	event CalculateBorrowRate(uint borrowRate);
		
	function _calculateBorrowRate() internal {
		uint _kinkUtilizationRate = kinkUtilizationRate;		
		uint _adjustSpeed = adjustSpeed;
		uint _borrowRate = borrowRate;	
		uint _kinkBorrowRate = kinkBorrowRate;
		uint32 _rateUpdateTimestamp = rateUpdateTimestamp;		
	
		// update kinkBorrowRate using previous borrowRate
		uint32 timeElapsed = getBlockTimestamp() - _rateUpdateTimestamp; // underflow is desired
		if(timeElapsed > 0) {
			rateUpdateTimestamp = getBlockTimestamp();
			uint adjustFactor;
			
			if (_borrowRate < _kinkBorrowRate) {
				// never overflows, _kinkBorrowRate is never 0
				uint tmp = (_kinkBorrowRate - _borrowRate) * 1e18 / _kinkBorrowRate * _adjustSpeed * timeElapsed / 1e18;
				adjustFactor = tmp > 1e18 ? 0 : 1e18 - tmp;
			} else {
				// never overflows, _kinkBorrowRate is never 0
				uint tmp = (_borrowRate - _kinkBorrowRate) * 1e18 / _kinkBorrowRate * _adjustSpeed * timeElapsed / 1e18;
				adjustFactor = tmp + 1e18;
			}
			
			// never overflows
			_kinkBorrowRate = _kinkBorrowRate * adjustFactor / 1e18;
			if(_kinkBorrowRate > KINK_BORROW_RATE_MAX) _kinkBorrowRate = KINK_BORROW_RATE_MAX;
			if(_kinkBorrowRate < KINK_BORROW_RATE_MIN) _kinkBorrowRate = KINK_BORROW_RATE_MIN;

			kinkBorrowRate = uint48(_kinkBorrowRate);
			emit CalculateKinkBorrowRate(_kinkBorrowRate);
		}
		
		uint _utilizationRate;
		{ // avoid stack to deep
		uint _totalBorrows = totalBorrows; // gas savings
		uint _actualBalance = totalBalance.add(_totalBorrows);
		_utilizationRate = (_actualBalance == 0) ? 0 : _totalBorrows * 1e18 / _actualBalance;
		}
		
		// update borrowRate using the new kinkBorrowRate	
		if(_utilizationRate <= _kinkUtilizationRate) {
			// never overflows, _kinkUtilizationRate is never 0
			_borrowRate = _kinkBorrowRate * _utilizationRate / _kinkUtilizationRate;
		} else {
			// never overflows, _kinkUtilizationRate is always < 1e18
			uint overUtilization = (_utilizationRate - _kinkUtilizationRate) * 1e18 / (1e18 - _kinkUtilizationRate);
			// never overflows
			_borrowRate = ((KINK_MULTIPLIER - 1) * overUtilization + 1e18) * _kinkBorrowRate / 1e18;
		}
		borrowRate = uint48(_borrowRate);
		emit CalculateBorrowRate(_borrowRate);
	}
	
	// applies accrued interest to total borrows and reserves
	function accrueInterest() public {
		uint _borrowIndex = borrowIndex;
		uint _totalBorrows = totalBorrows;
		uint32 _accrualTimestamp = accrualTimestamp;
		
		uint32 blockTimestamp = getBlockTimestamp();
		if (_accrualTimestamp == blockTimestamp) return;
		uint32 timeElapsed = blockTimestamp - _accrualTimestamp; // underflow is desired
		accrualTimestamp = blockTimestamp;
		
		uint interestFactor = uint(borrowRate).mul(timeElapsed);	
		uint interestAccumulated = interestFactor.mul(_totalBorrows).div(1e18);
		_totalBorrows = _totalBorrows.add( interestAccumulated );
		_borrowIndex = _borrowIndex.add( interestFactor.mul(_borrowIndex).div(1e18) );
	
		borrowIndex = safe112(_borrowIndex);
		totalBorrows = safe112(_totalBorrows);
		emit AccrueInterest(interestAccumulated, _borrowIndex, _totalBorrows);
	}
		
	function getBlockTimestamp() public view returns (uint32) {
		return uint32(block.timestamp % 2**32);
	}
}


// File contracts/interfaces/IFactory.sol

pragma solidity >=0.5.0;

interface IFactory {
	event LendingPoolInitialized(address indexed uniswapV2Pair, address indexed token0, address indexed token1,
		address collateral, address borrowable0, address borrowable1, uint lendingPoolId);
	event NewPendingAdmin(address oldPendingAdmin, address newPendingAdmin);
	event NewAdmin(address oldAdmin, address newAdmin);
	event NewReservesPendingAdmin(address oldReservesPendingAdmin, address newReservesPendingAdmin);
	event NewReservesAdmin(address oldReservesAdmin, address newReservesAdmin);
	event NewReservesManager(address oldReservesManager, address newReservesManager);
	
	function admin() external view returns (address);
	function pendingAdmin() external view returns (address);
	function reservesAdmin() external view returns (address);
	function reservesPendingAdmin() external view returns (address);
	function reservesManager() external view returns (address);

	function getLendingPool(address uniswapV2Pair) external view returns (
		bool initialized, 
		uint24 lendingPoolId, 
		address collateral, 
		address borrowable0, 
		address borrowable1
	);
	function allLendingPools(uint) external view returns (address uniswapV2Pair);
	function allLendingPoolsLength() external view returns (uint);
	
	function bDeployer() external view returns (address);
	function cDeployer() external view returns (address);
	function tarotPriceOracle() external view returns (address);

	function createCollateral(address uniswapV2Pair) external returns (address collateral);
	function createBorrowable0(address uniswapV2Pair) external returns (address borrowable0);
	function createBorrowable1(address uniswapV2Pair) external returns (address borrowable1);
	function initializeLendingPool(address uniswapV2Pair) external;

	function _setPendingAdmin(address newPendingAdmin) external;
	function _acceptAdmin() external;
	function _setReservesPendingAdmin(address newPendingAdmin) external;
	function _acceptReservesAdmin() external;
	function _setReservesManager(address newReservesManager) external;
}


// File contracts/BSetter.sol

pragma solidity =0.5.16;



contract BSetter is PoolToken, BStorage {
    uint256 public constant RESERVE_FACTOR_MAX = 0.20e18; //20%
    uint256 public constant KINK_UR_MIN = 0.50e18; //50%
    uint256 public constant KINK_UR_MAX = 0.99e18; //99%
    uint256 public constant ADJUST_SPEED_MIN = 0.05787037e12; //0.5% per day
    uint256 public constant ADJUST_SPEED_MAX = 5.787037e12; //50% per day

    event NewReserveFactor(uint256 newReserveFactor);
    event NewKinkUtilizationRate(uint256 newKinkUtilizationRate);
    event NewAdjustSpeed(uint256 newAdjustSpeed);
    event NewBorrowTracker(address newBorrowTracker);

    // called once by the factory at time of deployment
    function _initialize(
        string calldata _name,
        string calldata _symbol,
        address _underlying,
        address _collateral
    ) external {
        require(msg.sender == factory, "Tarot: UNAUTHORIZED"); // sufficient check
        _setName(_name, _symbol);
        underlying = _underlying;
        collateral = _collateral;
        exchangeRateLast = initialExchangeRate;
    }

    function _setReserveFactor(uint256 newReserveFactor) external nonReentrant {
        _checkSetting(newReserveFactor, 0, RESERVE_FACTOR_MAX);
        reserveFactor = newReserveFactor;
        emit NewReserveFactor(newReserveFactor);
    }

    function _setKinkUtilizationRate(uint256 newKinkUtilizationRate)
        external
        nonReentrant
    {
        _checkSetting(newKinkUtilizationRate, KINK_UR_MIN, KINK_UR_MAX);
        kinkUtilizationRate = newKinkUtilizationRate;
        emit NewKinkUtilizationRate(newKinkUtilizationRate);
    }

    function _setAdjustSpeed(uint256 newAdjustSpeed) external nonReentrant {
        _checkSetting(newAdjustSpeed, ADJUST_SPEED_MIN, ADJUST_SPEED_MAX);
        adjustSpeed = newAdjustSpeed;
        emit NewAdjustSpeed(newAdjustSpeed);
    }

    function _setBorrowTracker(address newBorrowTracker) external nonReentrant {
        _checkAdmin();
        borrowTracker = newBorrowTracker;
        emit NewBorrowTracker(newBorrowTracker);
    }

    function _checkSetting(
        uint256 parameter,
        uint256 min,
        uint256 max
    ) internal view {
        _checkAdmin();
        require(parameter >= min, "Tarot: INVALID_SETTING");
        require(parameter <= max, "Tarot: INVALID_SETTING");
    }

    function _checkAdmin() internal view {
        require(msg.sender == IFactory(factory).admin(), "Tarot: UNAUTHORIZED");
    }
}


// File contracts/interfaces/IBorrowable.sol

pragma solidity >=0.5.0;

interface IBorrowable {
    /*** Tarot ERC20 ***/

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /*** Pool Token ***/

    event Mint(
        address indexed sender,
        address indexed minter,
        uint256 mintAmount,
        uint256 mintTokens
    );
    event Redeem(
        address indexed sender,
        address indexed redeemer,
        uint256 redeemAmount,
        uint256 redeemTokens
    );
    event Sync(uint256 totalBalance);

    function underlying() external view returns (address);

    function factory() external view returns (address);

    function totalBalance() external view returns (uint256);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function exchangeRate() external returns (uint256);

    function mint(address minter) external returns (uint256 mintTokens);

    function redeem(address redeemer) external returns (uint256 redeemAmount);

    function skim(address to) external;

    function sync() external;

    function _setFactory() external;

    /*** Borrowable ***/

    event BorrowApproval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
    event Borrow(
        address indexed sender,
        address indexed borrower,
        address indexed receiver,
        uint256 borrowAmount,
        uint256 repayAmount,
        uint256 accountBorrowsPrior,
        uint256 accountBorrows,
        uint256 totalBorrows
    );
    event Liquidate(
        address indexed sender,
        address indexed borrower,
        address indexed liquidator,
        uint256 seizeTokens,
        uint256 repayAmount,
        uint256 accountBorrowsPrior,
        uint256 accountBorrows,
        uint256 totalBorrows
    );

    function BORROW_FEE() external pure returns (uint256);

    function collateral() external view returns (address);

    function reserveFactor() external view returns (uint256);

    function exchangeRateLast() external view returns (uint256);

    function borrowIndex() external view returns (uint256);

    function totalBorrows() external view returns (uint256);

    function borrowAllowance(address owner, address spender)
        external
        view
        returns (uint256);

    function borrowBalance(address borrower) external view returns (uint256);

    function borrowTracker() external view returns (address);

    function BORROW_PERMIT_TYPEHASH() external pure returns (bytes32);

    function borrowApprove(address spender, uint256 value)
        external
        returns (bool);

    function borrowPermit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    function borrow(
        address borrower,
        address receiver,
        uint256 borrowAmount,
        bytes calldata data
    ) external;

    function liquidate(address borrower, address liquidator)
        external
        returns (uint256 seizeTokens);

    function trackBorrow(address borrower) external;

    /*** Borrowable Interest Rate Model ***/

    event AccrueInterest(
        uint256 interestAccumulated,
        uint256 borrowIndex,
        uint256 totalBorrows
    );
    event CalculateKink(uint256 kinkRate);
    event CalculateBorrowRate(uint256 borrowRate);

    function KINK_BORROW_RATE_MAX() external pure returns (uint256);

    function KINK_BORROW_RATE_MIN() external pure returns (uint256);

    function KINK_MULTIPLIER() external pure returns (uint256);

    function borrowRate() external view returns (uint256);

    function kinkBorrowRate() external view returns (uint256);

    function kinkUtilizationRate() external view returns (uint256);

    function adjustSpeed() external view returns (uint256);

    function rateUpdateTimestamp() external view returns (uint32);

    function accrualTimestamp() external view returns (uint32);

    function accrueInterest() external;

    /*** Borrowable Setter ***/

    event NewReserveFactor(uint256 newReserveFactor);
    event NewKinkUtilizationRate(uint256 newKinkUtilizationRate);
    event NewAdjustSpeed(uint256 newAdjustSpeed);
    event NewBorrowTracker(address newBorrowTracker);

    function RESERVE_FACTOR_MAX() external pure returns (uint256);

    function KINK_UR_MIN() external pure returns (uint256);

    function KINK_UR_MAX() external pure returns (uint256);

    function ADJUST_SPEED_MIN() external pure returns (uint256);

    function ADJUST_SPEED_MAX() external pure returns (uint256);

    function _initialize(
        string calldata _name,
        string calldata _symbol,
        address _underlying,
        address _collateral
    ) external;

    function _setReserveFactor(uint256 newReserveFactor) external;

    function _setKinkUtilizationRate(uint256 newKinkUtilizationRate) external;

    function _setAdjustSpeed(uint256 newAdjustSpeed) external;

    function _setBorrowTracker(address newBorrowTracker) external;
}


// File contracts/interfaces/ICollateral.sol

pragma solidity >=0.5.0;

interface ICollateral {
    /*** Tarot ERC20 ***/

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );

    function name() external pure returns (string memory);

    function symbol() external pure returns (string memory);

    function decimals() external pure returns (uint8);

    function totalSupply() external view returns (uint256);

    function balanceOf(address owner) external view returns (uint256);

    function allowance(address owner, address spender)
        external
        view
        returns (uint256);

    function approve(address spender, uint256 value) external returns (bool);

    function transfer(address to, uint256 value) external returns (bool);

    function transferFrom(
        address from,
        address to,
        uint256 value
    ) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);

    function PERMIT_TYPEHASH() external pure returns (bytes32);

    function nonces(address owner) external view returns (uint256);

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /*** Pool Token ***/

    event Mint(
        address indexed sender,
        address indexed minter,
        uint256 mintAmount,
        uint256 mintTokens
    );
    event Redeem(
        address indexed sender,
        address indexed redeemer,
        uint256 redeemAmount,
        uint256 redeemTokens
    );
    event Sync(uint256 totalBalance);

    function underlying() external view returns (address);

    function factory() external view returns (address);

    function totalBalance() external view returns (uint256);

    function MINIMUM_LIQUIDITY() external pure returns (uint256);

    function exchangeRate() external returns (uint256);

    function mint(address minter) external returns (uint256 mintTokens);

    function redeem(address redeemer) external returns (uint256 redeemAmount);

    function skim(address to) external;

    function sync() external;

    function _setFactory() external;

    /*** Collateral ***/

    function borrowable0() external view returns (address);

    function borrowable1() external view returns (address);

    function tarotPriceOracle() external view returns (address);

    function safetyMarginSqrt() external view returns (uint256);

    function liquidationIncentive() external view returns (uint256);

    function getPrices() external returns (uint256 price0, uint256 price1);

    function tokensUnlocked(address from, uint256 value)
        external
        returns (bool);

    function accountLiquidityAmounts(
        address account,
        uint256 amount0,
        uint256 amount1
    ) external returns (uint256 liquidity, uint256 shortfall);

    function accountLiquidity(address account)
        external
        returns (uint256 liquidity, uint256 shortfall);

    function canBorrow(
        address account,
        address borrowable,
        uint256 accountBorrows
    ) external returns (bool);

    function seize(
        address liquidator,
        address borrower,
        uint256 repayAmount
    ) external returns (uint256 seizeTokens);

    function flashRedeem(
        address redeemer,
        uint256 redeemAmount,
        bytes calldata data
    ) external;

    /*** Collateral Setter ***/

    event NewSafetyMargin(uint256 newSafetyMarginSqrt);
    event NewLiquidationIncentive(uint256 newLiquidationIncentive);

    function SAFETY_MARGIN_SQRT_MIN() external pure returns (uint256);

    function SAFETY_MARGIN_SQRT_MAX() external pure returns (uint256);

    function LIQUIDATION_INCENTIVE_MIN() external pure returns (uint256);

    function LIQUIDATION_INCENTIVE_MAX() external pure returns (uint256);

    function _initialize(
        string calldata _name,
        string calldata _symbol,
        address _underlying,
        address _borrowable0,
        address _borrowable1
    ) external;

    function _setSafetyMarginSqrt(uint256 newSafetyMarginSqrt) external;

    function _setLiquidationIncentive(uint256 newLiquidationIncentive) external;
}


// File contracts/interfaces/ITarotCallee.sol

pragma solidity >=0.5.0;

interface ITarotCallee {
    function tarotBorrow(
        address sender,
        address borrower,
        uint256 borrowAmount,
        bytes calldata data
    ) external;

    function tarotRedeem(
        address sender,
        uint256 redeemAmount,
        bytes calldata data
    ) external;
}


// File contracts/interfaces/IBorrowTracker.sol

pragma solidity >=0.5.0;

interface IBorrowTracker {
	function trackBorrow(address borrower, uint borrowBalance, uint borrowIndex) external;
}


// File contracts/libraries/Math.sol

pragma solidity =0.5.16;

// a library for performing various math operations
// forked from: https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/libraries/Math.sol

library Math {
    function min(uint x, uint y) internal pure returns (uint z) {
        z = x < y ? x : y;
    }

    // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
    function sqrt(uint y) internal pure returns (uint z) {
        if (y > 3) {
            z = y;
            uint x = y / 2 + 1;
            while (x < z) {
                z = x;
                x = (y / x + x) / 2;
            }
        } else if (y != 0) {
            z = 1;
        }
    }
}


// File contracts/Borrowable.sol

pragma solidity =0.5.16;












contract Borrowable is
    IBorrowable,
    PoolToken,
    BStorage,
    BSetter,
    BInterestRateModel,
    BAllowance
{
    uint256 public constant BORROW_FEE = 0.001e18; //0.1%

    event Borrow(
        address indexed sender,
        address indexed borrower,
        address indexed receiver,
        uint256 borrowAmount,
        uint256 repayAmount,
        uint256 accountBorrowsPrior,
        uint256 accountBorrows,
        uint256 totalBorrows
    );
    event Liquidate(
        address indexed sender,
        address indexed borrower,
        address indexed liquidator,
        uint256 seizeTokens,
        uint256 repayAmount,
        uint256 accountBorrowsPrior,
        uint256 accountBorrows,
        uint256 totalBorrows
    );

    constructor() public {}

    /*** PoolToken ***/

    function _update() internal {
        super._update();
        _calculateBorrowRate();
    }

    function _mintReserves(uint256 _exchangeRate, uint256 _totalSupply)
        internal
        returns (uint256)
    {
        uint256 _exchangeRateLast = exchangeRateLast;
        if (_exchangeRate > _exchangeRateLast) {
            uint256 _exchangeRateNew =
                _exchangeRate.sub(
                    _exchangeRate.sub(_exchangeRateLast).mul(reserveFactor).div(
                        1e18
                    )
                );
            uint256 liquidity =
                _totalSupply.mul(_exchangeRate).div(_exchangeRateNew).sub(
                    _totalSupply
                );
            if (liquidity == 0) return _exchangeRate;
            address reservesManager = IFactory(factory).reservesManager();
            _mint(reservesManager, liquidity);
            exchangeRateLast = _exchangeRateNew;
            return _exchangeRateNew;
        } else return _exchangeRate;
    }

    function exchangeRate() public accrue returns (uint256) {
        uint256 _totalSupply = totalSupply;
        uint256 _actualBalance = totalBalance.add(totalBorrows);
        if (_totalSupply == 0 || _actualBalance == 0)
            return initialExchangeRate;
        uint256 _exchangeRate = _actualBalance.mul(1e18).div(_totalSupply);
        return _mintReserves(_exchangeRate, _totalSupply);
    }

    // force totalBalance to match real balance
    function sync() external nonReentrant update accrue {}

    /*** Borrowable ***/

    // this is the stored borrow balance; the current borrow balance may be slightly higher
    function borrowBalance(address borrower) public view returns (uint256) {
        BorrowSnapshot memory borrowSnapshot = borrowBalances[borrower];
        if (borrowSnapshot.interestIndex == 0) return 0; // not initialized
        return
            uint256(borrowSnapshot.principal).mul(borrowIndex).div(
                borrowSnapshot.interestIndex
            );
    }

    function _trackBorrow(
        address borrower,
        uint256 accountBorrows,
        uint256 _borrowIndex
    ) internal {
        address _borrowTracker = borrowTracker;
        if (_borrowTracker == address(0)) return;
        IBorrowTracker(_borrowTracker).trackBorrow(
            borrower,
            accountBorrows,
            _borrowIndex
        );
    }

    function _updateBorrow(
        address borrower,
        uint256 borrowAmount,
        uint256 repayAmount
    )
        private
        returns (
            uint256 accountBorrowsPrior,
            uint256 accountBorrows,
            uint256 _totalBorrows
        )
    {
        accountBorrowsPrior = borrowBalance(borrower);
        if (borrowAmount == repayAmount)
            return (accountBorrowsPrior, accountBorrowsPrior, totalBorrows);
        uint112 _borrowIndex = borrowIndex;
        if (borrowAmount > repayAmount) {
            BorrowSnapshot storage borrowSnapshot = borrowBalances[borrower];
            uint256 increaseAmount = borrowAmount - repayAmount;
            accountBorrows = accountBorrowsPrior.add(increaseAmount);
            borrowSnapshot.principal = safe112(accountBorrows);
            borrowSnapshot.interestIndex = _borrowIndex;
            _totalBorrows = uint256(totalBorrows).add(increaseAmount);
            totalBorrows = safe112(_totalBorrows);
        } else {
            BorrowSnapshot storage borrowSnapshot = borrowBalances[borrower];
            uint256 decreaseAmount = repayAmount - borrowAmount;
            accountBorrows = accountBorrowsPrior > decreaseAmount
                ? accountBorrowsPrior - decreaseAmount
                : 0;
            borrowSnapshot.principal = safe112(accountBorrows);
            if (accountBorrows == 0) {
                borrowSnapshot.interestIndex = 0;
            } else {
                borrowSnapshot.interestIndex = _borrowIndex;
            }
            uint256 actualDecreaseAmount =
                accountBorrowsPrior.sub(accountBorrows);
            _totalBorrows = totalBorrows; // gas savings
            _totalBorrows = _totalBorrows > actualDecreaseAmount
                ? _totalBorrows - actualDecreaseAmount
                : 0;
            totalBorrows = safe112(_totalBorrows);
        }
        _trackBorrow(borrower, accountBorrows, _borrowIndex);
    }

    // this low-level function should be called from another contract
    function borrow(
        address borrower,
        address receiver,
        uint256 borrowAmount,
        bytes calldata data
    ) external nonReentrant update accrue {
        uint256 _totalBalance = totalBalance;
        require(borrowAmount <= _totalBalance, "Tarot: INSUFFICIENT_CASH");
        _checkBorrowAllowance(borrower, msg.sender, borrowAmount);

        // optimistically transfer funds
        if (borrowAmount > 0) _safeTransfer(receiver, borrowAmount);
        if (data.length > 0)
            ITarotCallee(receiver).tarotBorrow(
                msg.sender,
                borrower,
                borrowAmount,
                data
            );
        uint256 balance = IERC20(underlying).balanceOf(address(this));

        uint256 borrowFee = borrowAmount.mul(BORROW_FEE).div(1e18);
        uint256 adjustedBorrowAmount = borrowAmount.add(borrowFee);
        uint256 repayAmount = balance.add(borrowAmount).sub(_totalBalance);
        (
            uint256 accountBorrowsPrior,
            uint256 accountBorrows,
            uint256 _totalBorrows
        ) = _updateBorrow(borrower, adjustedBorrowAmount, repayAmount);

        if (adjustedBorrowAmount > repayAmount)
            require(
                ICollateral(collateral).canBorrow(
                    borrower,
                    address(this),
                    accountBorrows
                ),
                "Tarot: INSUFFICIENT_LIQUIDITY"
            );

        emit Borrow(
            msg.sender,
            borrower,
            receiver,
            borrowAmount,
            repayAmount,
            accountBorrowsPrior,
            accountBorrows,
            _totalBorrows
        );
    }

    // this low-level function should be called from another contract
    function liquidate(address borrower, address liquidator)
        external
        nonReentrant
        update
        accrue
        returns (uint256 seizeTokens)
    {
        uint256 balance = IERC20(underlying).balanceOf(address(this));
        uint256 repayAmount = balance.sub(totalBalance);

        uint256 actualRepayAmount =
            Math.min(borrowBalance(borrower), repayAmount);
        seizeTokens = ICollateral(collateral).seize(
            liquidator,
            borrower,
            actualRepayAmount
        );
        (
            uint256 accountBorrowsPrior,
            uint256 accountBorrows,
            uint256 _totalBorrows
        ) = _updateBorrow(borrower, 0, repayAmount);

        emit Liquidate(
            msg.sender,
            borrower,
            liquidator,
            seizeTokens,
            repayAmount,
            accountBorrowsPrior,
            accountBorrows,
            _totalBorrows
        );
    }

    function trackBorrow(address borrower) external {
        _trackBorrow(borrower, borrowBalance(borrower), borrowIndex);
    }

    modifier accrue() {
        accrueInterest();
        _;
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"interestAccumulated","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"borrowIndex","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalBorrows","type":"uint256"}],"name":"AccrueInterest","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":false,"internalType":"uint256","name":"borrowAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"repayAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accountBorrowsPrior","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accountBorrows","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalBorrows","type":"uint256"}],"name":"Borrow","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"BorrowApproval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"borrowRate","type":"uint256"}],"name":"CalculateBorrowRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"kinkRate","type":"uint256"}],"name":"CalculateKink","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"kinkBorrowRate","type":"uint256"}],"name":"CalculateKinkBorrowRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"borrower","type":"address"},{"indexed":true,"internalType":"address","name":"liquidator","type":"address"},{"indexed":false,"internalType":"uint256","name":"seizeTokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"repayAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accountBorrowsPrior","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"accountBorrows","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"totalBorrows","type":"uint256"}],"name":"Liquidate","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"minter","type":"address"},{"indexed":false,"internalType":"uint256","name":"mintAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"mintTokens","type":"uint256"}],"name":"Mint","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newAdjustSpeed","type":"uint256"}],"name":"NewAdjustSpeed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"newBorrowTracker","type":"address"}],"name":"NewBorrowTracker","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newKinkUtilizationRate","type":"uint256"}],"name":"NewKinkUtilizationRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newReserveFactor","type":"uint256"}],"name":"NewReserveFactor","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"redeemer","type":"address"},{"indexed":false,"internalType":"uint256","name":"redeemAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"redeemTokens","type":"uint256"}],"name":"Redeem","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"totalBalance","type":"uint256"}],"name":"Sync","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"constant":true,"inputs":[],"name":"ADJUST_SPEED_MAX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"ADJUST_SPEED_MIN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"BORROW_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"BORROW_PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"KINK_BORROW_RATE_MAX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"KINK_BORROW_RATE_MIN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"KINK_MULTIPLIER","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"KINK_UR_MAX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"KINK_UR_MIN","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"MINIMUM_LIQUIDITY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"RESERVE_FACTOR_MAX","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_underlying","type":"address"},{"internalType":"address","name":"_collateral","type":"address"}],"name":"_initialize","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newAdjustSpeed","type":"uint256"}],"name":"_setAdjustSpeed","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"newBorrowTracker","type":"address"}],"name":"_setBorrowTracker","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"_setFactory","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newKinkUtilizationRate","type":"uint256"}],"name":"_setKinkUtilizationRate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"uint256","name":"newReserveFactor","type":"uint256"}],"name":"_setReserveFactor","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"accrualTimestamp","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"accrueInterest","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"adjustSpeed","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":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"borrower","type":"address"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"borrowAmount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"borrow","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"address","name":"","type":"address"}],"name":"borrowAllowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"borrowApprove","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"borrower","type":"address"}],"name":"borrowBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"borrowIndex","outputs":[{"internalType":"uint112","name":"","type":"uint112"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"borrowPermit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"borrowRate","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"borrowTracker","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"collateral","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"exchangeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"exchangeRateLast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"factory","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"getBlockTimestamp","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"kinkBorrowRate","outputs":[{"internalType":"uint48","name":"","type":"uint48"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"kinkUtilizationRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"borrower","type":"address"},{"internalType":"address","name":"liquidator","type":"address"}],"name":"liquidate","outputs":[{"internalType":"uint256","name":"seizeTokens","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"mintTokens","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"rateUpdateTimestamp","outputs":[{"internalType":"uint32","name":"","type":"uint32"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"redeemer","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"redeemAmount","type":"uint256"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"reserveFactor","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"}],"name":"skim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"sync","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"totalBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalBorrows","outputs":[{"internalType":"uint112","name":"","type":"uint112"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"borrower","type":"address"}],"name":"trackBorrow","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"underlying","outputs":[{"internalType":"address","name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"}]

Contract Creation Code

Decompile ByteCode Switch to Opcodes View

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

Deployed ByteCode Sourcemap

43326:8418:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;43326:8418:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21514:124;;;:::i;:::-;;;;;;;;;;;;;;;;7002:18;;;:::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;7002:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28511:56;;;:::i;9148:150::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;9148:150:0;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;7087:26;;;:::i;19992:44::-;;;:::i;48723:1742::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;48723:1742:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;48723:1742:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;48723:1742:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;-1:-1;48723:1742:0;;-1:-1:-1;48723:1742:0;-1:-1:-1;48723:1742:0;:::i;:::-;;28395:45;;;:::i;9456:421::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;9456:421:0;;;;;;;;;;;;;;;;;:::i;28589:54::-;;;:::i;29936:240::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;29936:240:0;;:::i;20049:41::-;;;:::i;11050:117::-;;;:::i;7054:26::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;30184:200;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;30184:200:0;-1:-1:-1;;;;;30184:200:0;;:::i;7244:31::-;;;:::i;45211:408::-;;;:::i;19941:38::-;;;:::i;22481:56::-;;;:::i;19595:27::-;;;:::i;:::-;;;;-1:-1:-1;;;;;19595:27:0;;;;;;;;;;;;;;15675:142;;;:::i;45859:377::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;45859:377:0;-1:-1:-1;;;;;45859:377:0;;:::i;20110:28::-;;;:::i;:::-;;;;-1:-1:-1;;;;;20110:28:0;;;;;;;;;;;;;;22437:40;;;:::i;28453:45::-;;;:::i;28953:409::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;28953:409:0;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;28953:409:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;28953:409:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;28953:409:0;;;;;;;;;;;21:11:-1;5:28;;2:2;;;46:1;43;36:12;2:2;28953:409:0;;35:9:-1;28:4;12:14;8:25;5:40;2:2;;;58:1;55;48:12;2:2;28953:409:0;;;;;;100:9:-1;95:1;81:12;77:20;67:8;63:35;60:50;39:11;25:12;22:29;11:107;8:2;;;131:1;128;121:12;8:2;28953:409:0;;-1:-1:-1;28953:409:0;-1:-1:-1;;;;;;28953:409:0;;;;;;;;;;:::i;16398:717::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;16398:717:0;-1:-1:-1;;;;;16398:717:0;;:::i;19183:70::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;19183:70:0;;;;;;;;;;:::i;15115:25::-;;;:::i;7120:44::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7120:44:0;-1:-1:-1;;;;;7120:44:0;;:::i;25962:106::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;7282:41;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;7282:41:0;-1:-1:-1;;;;;7282:41:0;;:::i;50544:989::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;50544:989:0;;;;;;;;;;:::i;19801:42::-;;;:::i;:::-;;;;;;;;;;;;;;;;;;;20774:185;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;20774:185:0;;;;;;;;:::i;29619:309::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;29619:309:0;;:::i;17194:577::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;17194:577:0;-1:-1:-1;;;;;17194:577:0;;:::i;7027:20::-;;;:::i;21647:460::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;21647:460:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;43461:45::-;;;:::i;25127:828::-;;;:::i;9306:142::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;9306:142:0;;;;;;;;:::i;19555:33::-;;;:::i;15176:27::-;;;:::i;51541:127::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;51541:127:0;-1:-1:-1;;;;;51541:127:0;;:::i;19629:64::-;;;:::i;15210:48::-;;;:::i;17828:184::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;17828:184:0;-1:-1:-1;;;;;17828:184:0;;:::i;19702:31::-;;;:::i;15147:22::-;;;:::i;28330:52::-;;;:::i;19770:24::-;;;:::i;11176:441::-;;;;;;13:3:-1;8;5:12;2:2;;;30:1;27;20:12;2:2;-1:-1;;;;;;11176:441:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;19149:25::-;;;:::i;7171:64::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;;;;;;7171:64:0;;;;;;;;;;:::i;22557:56::-;;;:::i;19865:67::-;;;:::i;29370:241::-;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;29370:241:0;;:::i;45676:54::-;;;:::i;21514:124::-;21572:66;21514:124;:::o;7002:18::-;;;;;;;;;;;;;;;-1:-1:-1;;7002:18:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;28511:56::-;28554:13;28511:56;:::o;9148:150::-;9215:4;9232:36;9241:10;9253:7;9262:5;9232:8;:36::i;:::-;-1:-1:-1;9286:4:0;9148:150;;;;;:::o;7087:26::-;;;;:::o;19992:44::-;;;;:::o;48723:1742::-;18827:11;;;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;51705:16;:14;:16::i;:::-;48932:12;;48963:29;;;;48955:66;;;;;-1:-1:-1;;;48955:66:0;;;;;;;;;;;;-1:-1:-1;;;48955:66:0;;;;;;;;;;;;;;;49032:57;49054:8;49064:10;49076:12;49032:21;:57::i;:::-;49148:16;;49144:59;;49166:37;49180:8;49190:12;49166:13;:37::i;:::-;49218:15;;49214:193;;49248:159;;-1:-1:-1;;;49248:159:0;;49301:10;49248:159;;;;;;-1:-1:-1;;;;;49248:159:0;;;;;;;;;;;;;;;;;;;;;;;;;;:34;;;;;;49301:10;49330:8;;49357:12;;49388:4;;;;49248:159;;;;49388:4;;;;49248:159;1:33:-1;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;49248:159:0;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49248:159:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49248:159:0;;;;49214:193;49443:10;;49436:43;;;-1:-1:-1;;;49436:43:0;;49473:4;49436:43;;;;;;49418:15;;-1:-1:-1;;;;;49443:10:0;;49436:28;;:43;;;;;;;;;;;;;;49443:10;49436:43;;;5:2:-1;;;;30:1;27;20:12;5:2;49436:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49436:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;49436:43:0;;-1:-1:-1;49492:17:0;49512:38;49545:4;49512:28;:12;43498:8;49512:28;:16;:28;:::i;:::-;:32;:38;:32;:38;:::i;:::-;49492:58;-1:-1:-1;49561:28:0;49592:27;:12;49492:58;49592:27;:16;:27;:::i;:::-;49561:58;-1:-1:-1;49630:19:0;49652:44;49682:13;49652:25;:7;49664:12;49652:25;:11;:25;:::i;:::-;:29;:44;:29;:44;:::i;:::-;49630:66;;49722:27;49764:22;49801:21;49836:58;49850:8;49860:20;49882:11;49836:13;:58::i;:::-;49707:187;;;;;;49934:11;49911:20;:34;49907:300;;;49998:10;;;;;;;;;-1:-1:-1;;;;;49998:10:0;-1:-1:-1;;;;;49986:33:0;;50042:8;50081:4;50109:14;49986:156;;;;;;;;;;;;;-1:-1:-1;;;;;49986:156:0;-1:-1:-1;;;;;49986:156:0;;;;;;-1:-1:-1;;;;;49986:156:0;-1:-1:-1;;;;;49986:156:0;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49986:156:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49986:156:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;49986:156:0;49960:247;;;;;-1:-1:-1;;;49960:247:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;50294:8;-1:-1:-1;;;;;50225:232:0;50271:8;-1:-1:-1;;;;;50225:232:0;50246:10;-1:-1:-1;;;;;50225:232:0;;50317:12;50344:11;50370:19;50404:14;50433:13;50225:232;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51732:1;;;;;;;;19036:9;:7;:9::i;:::-;-1:-1:-1;;18912:11:0;:18;;-1:-1:-1;;18912:18:0;18926:4;18912:18;;;-1:-1:-1;;;48723:1742:0:o;28395:45::-;28433:7;28395:45;:::o;9456:421::-;-1:-1:-1;;;;;9592:15:0;;9571:4;9592:15;;;:9;:15;;;;;;;;9608:10;9592:27;;;;;;;;-1:-1:-1;;9592:42:0;9588:223;;9681:118;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9681:15:0;;-1:-1:-1;9681:15:0;;;:9;:15;;;;;9697:10;9681:27;;;;;;;;;;:118;;9731:5;;9681:118;:31;:118;:::i;:::-;-1:-1:-1;;;;;9651:15:0;;;;;;:9;:15;;;;;;;;9667:10;9651:27;;;;;;;:148;9588:223;9821:26;9831:4;9837:2;9841:5;9821:9;:26::i;:::-;-1:-1:-1;9865:4:0;9456:421;;;;;:::o;28589:54::-;28632:11;28589:54;:::o;29936:240::-;18827:11;;;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;30018:65;30032:14;28554:13;28632:11;30018:13;:65::i;:::-;30094:11;:28;;;30138:30;;;;;;;;;;;;;;;;;-1:-1:-1;18912:11:0;:18;;-1:-1:-1;;18912:18:0;18926:4;18912:18;;;29936:240::o;20049:41::-;;;;:::o;11050:117::-;11101:66;11050:117;:::o;7054:26::-;;;;;;:::o;30184:200::-;18827:11;;;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;30270:13;:11;:13::i;:::-;30294;:32;;-1:-1:-1;;;;;30294:32:0;;-1:-1:-1;;;;;;30294:32:0;;;;;;;;30342:34;;;;;;;;;;;;;;;;-1:-1:-1;18912:11:0;:18;;-1:-1:-1;;18912:18:0;18926:4;18912:18;;;30184:200::o;7244:31::-;;;;:::o;45211:408::-;45258:7;51705:16;:14;:16::i;:::-;45301:11;;45365:12;;45348;;45278:20;;45348:30;;:12;-1:-1:-1;;;45365:12:0;;-1:-1:-1;;;;;45365:12:0;45348:16;:30::i;:::-;45323:55;-1:-1:-1;45393:17:0;;;:40;;-1:-1:-1;45414:19:0;;45393:40;45389:85;;;15104:4;45448:26;;;;;;45389:85;45485:21;45509:42;45538:12;45509:24;:14;45528:4;45509:24;:18;:24;:::i;:42::-;45485:66;;45569:42;45583:13;45598:12;45569:13;:42::i;:::-;45562:49;;;;;51732:1;45211:408;:::o;19941:38::-;;;;:::o;22481:56::-;22525:12;22481:56;:::o;19595:27::-;;;-1:-1:-1;;;19595:27:0;;-1:-1:-1;;;;;19595:27:0;;:::o;15675:142::-;15726:7;;-1:-1:-1;;;;;15726:7:0;:21;15718:60;;;;;-1:-1:-1;;;15718:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;15789:7;:20;;-1:-1:-1;;;;;;15789:20:0;15799:10;15789:20;;;15675:142::o;45859:377::-;45921:7;45941:36;;:::i;:::-;-1:-1:-1;;;;;;45980:24:0;;;;;;:14;:24;;;;;;;;;45941:63;;;;;;;;;-1:-1:-1;;;;;45941:63:0;;;;;-1:-1:-1;;;45941:63:0;;;;;;;;;;46015:47;;46061:1;46054:8;;;;;46015:47;46185:28;;;;46150:11;;46120:24;;46112:116;;-1:-1:-1;;;;;46112:116:0;;;;:50;;:33;;;46150:11;46112:50;:37;:50;:::i;:116::-;46092:136;;;45859:377;;;;:::o;20110:28::-;;;-1:-1:-1;;;;;20110:28:0;;:::o;22437:40::-;22476:1;22437:40;:::o;28453:45::-;28491:7;28453:45;:::o;28953:409::-;29149:7;;-1:-1:-1;;;;;29149:7:0;29135:10;:21;29127:53;;;;;-1:-1:-1;;;29127:53:0;;;;;;;;;;;;-1:-1:-1;;;29127:53:0;;;;;;;;;;;;;;;29211:24;29220:5;;29211:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;;29211:24:0;;;;137:4:-1;29211:24:0;;;;;;;;;;;;;;;;;;-1:-1:-1;29227:7:0;;-1:-1:-1;29227:7:0;;;;29211:24;;29227:7;;;;29211:24;1:33:-1;99:1;81:16;;74:27;;;;-1:-1;29211:8:0;;-1:-1:-1;;;29211:24:0:i;:::-;29246:10;:24;;-1:-1:-1;;;;;29246:24:0;;;-1:-1:-1;;;;;;29246:24:0;;;;;;29281:10;:24;;;;;;29246;29281;-1:-1:-1;;;;;;29281:24:0;;;;;;-1:-1:-1;;15104:4:0;29316:16;:38;-1:-1:-1;;28953:409:0:o;16398:717::-;18827:11;;16502:18;;18827:11;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;16563:10;;16556:43;;;-1:-1:-1;;;16556:43:0;;16593:4;16556:43;;;;;;18884:5;;-1:-1:-1;;;;;16563:10:0;;16556:28;;:43;;;;;;;;;;;;;;16563:10;16556:43;;;5:2:-1;;;;30:1;27;20:12;5:2;16556:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;16556:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;16556:43:0;16643:12;;16556:43;;-1:-1:-1;16610:18:0;;16631:25;;16556:43;;16631:25;:11;:25;:::i;:::-;16610:46;;16680:40;16705:14;:12;:14::i;:::-;16680:20;:10;16695:4;16680:20;:14;:20;:::i;:40::-;16667:53;;16737:11;;16752:1;16737:16;16733:214;;;16851:33;:10;15254:4;16851:33;:14;:33;:::i;:::-;16838:46;;16899:36;16913:1;15254:4;16899:5;:36::i;:::-;16978:1;16965:10;:14;16957:50;;;;;-1:-1:-1;;;16957:50:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;17018:25;17024:6;17032:10;17018:5;:25::i;:::-;17059:48;;;;;;;;;;;;;;-1:-1:-1;;;;;17059:48:0;;;17064:10;;17059:48;;;;;;;;;;;19024:1;;19036:9;:7;:9::i;:::-;18912:11;:18;;-1:-1:-1;;18912:18:0;18926:4;18912:18;;;16398:717;;-1:-1:-1;16398:717:0:o;19183:70::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;15115:25::-;;;-1:-1:-1;;;;;15115:25:0;;:::o;7120:44::-;;;;;;;;;;;;;:::o;25962:106::-;26039:23;:15;:23;;25962:106::o;7282:41::-;;;;;;;;;;;;;:::o;50544:989::-;18827:11;;50691:19;;18827:11;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;51705:16;:14;:16::i;:::-;50753:10;;50746:43;;;-1:-1:-1;;;50746:43:0;;50783:4;50746:43;;;;;;50728:15;;-1:-1:-1;;;;;50753:10:0;;50746:28;;:43;;;;;;;;;;;;;;50753:10;50746:43;;;5:2:-1;;;;30:1;27;20:12;5:2;50746:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50746:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50746:43:0;50834:12;;50746:43;;-1:-1:-1;50800:19:0;;50822:25;;50746:43;;50822:25;:11;:25;:::i;:::-;50800:47;;50860:25;50901:46;50910:23;50924:8;50910:13;:23::i;:::-;50935:11;50901:8;:46::i;:::-;50984:10;;50972:120;;;-1:-1:-1;;;50972:120:0;;-1:-1:-1;;;;;50972:120:0;;;;;;;;;;;;;;;;;;;;;;50860:87;;-1:-1:-1;50984:10:0;;;;;;50972:29;;:120;;;;;;;;;;;;;;;-1:-1:-1;50984:10:0;50972:120;;;5:2:-1;;;;30:1;27;20:12;5:2;50972:120:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50972:120:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;50972:120:0;;-1:-1:-1;51118:27:0;;;51232:39;51246:8;51118:27;51259:11;51232:13;:39::i;:::-;51289:236;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51103:168;;-1:-1:-1;51103:168:0;;-1:-1:-1;51103:168:0;-1:-1:-1;;;;;;51289:236:0;;;;;;;;51313:10;;51289:236;;;;;;;;;51732:1;;;;;;19036:9;:7;:9::i;:::-;18912:11;:18;;-1:-1:-1;;18912:18:0;18926:4;18912:18;;;50544:989;;-1:-1:-1;;50544:989:0:o;19801:42::-;;;-1:-1:-1;;;19801:42:0;;;;;:::o;20774:185::-;20865:4;20887:42;20902:10;20914:7;20923:5;20887:14;:42::i;29619:309::-;18827:11;;;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;29740:63;29754:22;28433:7;28491;29740:13;:63::i;:::-;29814:19;:44;;;29874:46;;;;;;;;;;;;;;;;;-1:-1:-1;18912:11:0;:18;;-1:-1:-1;;18912:18:0;18926:4;18912:18;;;29619:309::o;17194:577::-;18827:11;;17302:20;;18827:11;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;17381:4;18884:5;17363:24;;;:9;:24;;;;;;17413:42;17450:4;17413:32;17430:14;:12;:14::i;:::-;17413:12;;:32;:16;:32;:::i;:42::-;17398:57;;17491:1;17476:12;:16;17468:54;;;;;-1:-1:-1;;;17468:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;17557:12;;17541;:28;;17533:65;;;;;-1:-1:-1;;;17533:65:0;;;;;;;;;;;;-1:-1:-1;;;17533:65:0;;;;;;;;;;;;;;;17609:34;17623:4;17630:12;17609:5;:34::i;:::-;17654:37;17668:8;17678:12;17654:13;:37::i;:::-;17707:56;;;;;;;;;;;;;;-1:-1:-1;;;;;17707:56:0;;;17714:10;;17707:56;;;;;;;;;;;19024:1;19036:9;:7;:9::i;7027:20::-;;;;;;;;;;;;;;;-1:-1:-1;;7027:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21647:460;21855:196;21885:5;21905:7;21927:5;21947:8;21970:1;21986;22002;21572:66;21855:15;:196::i;:::-;22062:37;22077:5;22084:7;22093:5;22062:14;:37::i;:::-;21647:460;;;;;;;:::o;43461:45::-;43498:8;43461:45;:::o;25127:828::-;25185:11;;-1:-1:-1;;;;;25185:11:0;;;;-1:-1:-1;;;25222:12:0;;;;;;-1:-1:-1;;;25266:16:0;;;;25165:17;25315:19;:17;:19::i;:::-;25291:43;;25364:14;25343:35;;:17;:35;;;25339:48;;;25380:7;;;;;;25339:48;25475:16;:33;;;;;;-1:-1:-1;;;25475:33:0;-1:-1:-1;;;;;25475:33:0;;;;;;;;;;25544:10;;25412:34;;;;25391:18;;25539:33;;25544:10;;;;;25539:33;;;;:20;:33;:::i;:::-;25517:55;-1:-1:-1;25578:24:0;25605:43;25643:4;25605:33;25517:55;25624:13;25605:33;:18;:33;:::i;:43::-;25578:70;-1:-1:-1;25669:40:0;:13;25578:70;25669:40;:17;:40;:::i;:::-;25653:56;-1:-1:-1;25729:62:0;25747:42;25784:4;25747:32;:14;25766:12;25747:32;:18;:32;:::i;:42::-;25729:12;;:62;:16;:62;:::i;:::-;25714:77;;25813:21;25821:12;25813:7;:21::i;:::-;25799:11;:35;;-1:-1:-1;;;;;;25799:35:0;-1:-1:-1;;;;;25799:35:0;;;;;;;;;;25854:22;25862:13;25854:7;:22::i;:::-;25839:12;:37;;-1:-1:-1;;;;;25839:37:0;;;;-1:-1:-1;;;25839:37:0;-1:-1:-1;;;;;;;;25839:37:0;;;;;;;;;25886:64;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25127:828;;;;;;;;:::o;9306:142::-;9369:4;9386:32;9396:10;9408:2;9412:5;9386:9;:32::i;19555:33::-;;;-1:-1:-1;;;;;19555:33:0;;:::o;15176:27::-;;;;:::o;51541:127::-;51600:60;51613:8;51623:23;51637:8;51623:13;:23::i;:::-;51648:11;;-1:-1:-1;;;;;51648:11:0;51600:12;:60::i;:::-;51541:127;:::o;19629:64::-;;;-1:-1:-1;;;19629:64:0;;;;;:::o;15210:48::-;15254:4;15210:48;:::o;17828:184::-;18827:11;;;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;17980:12;;17939:10;;17932:43;;;-1:-1:-1;;;17932:43:0;;17969:4;17932:43;;;;;;17887:117;;17915:2;;17932:61;;17980:12;;-1:-1:-1;;;;;17939:10:0;;;;17932:28;;:43;;;;;;;;;;;;;;17939:10;17932:43;;;5:2:-1;;;;30:1;27;20:12;5:2;17932:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;17932:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;17932:43:0;;:61;:47;:61;:::i;:::-;17887:13;:117::i;:::-;-1:-1:-1;18912:11:0;:18;;-1:-1:-1;;18912:18:0;18926:4;18912:18;;;17828:184::o;19702:31::-;;;;:::o;15147:22::-;;;-1:-1:-1;;;;;15147:22:0;;:::o;28330:52::-;28375:7;28330:52;:::o;19770:24::-;;;;;;:::o;11176:441::-;11378:189;11408:5;11428:7;11450:5;11470:8;11493:1;11509;11525;11101:66;11378:15;:189::i;:::-;11578:31;11587:5;11594:7;11603:5;11578:8;:31::i;19149:25::-;;;;;;-1:-1:-1;;;;;19149:25:0;;:::o;7171:64::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;22557:56::-;22601:12;22557:56;:::o;19865:67::-;;;-1:-1:-1;;;19865:67:0;;;;;:::o;29370:241::-;18827:11;;;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;29456:54;29470:16;18884:5;28375:7;29456:13;:54::i;:::-;29521:13;:32;;;29569:34;;;;;;;;;;;;;;;;;-1:-1:-1;18912:11:0;:18;;-1:-1:-1;;18912:18:0;18926:4;18912:18;;;29370:241::o;45676:54::-;18827:11;;;;18819:40;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;-1:-1:-1;;;18819:40:0;;;;;;;;;;;;;;;18870:11;:19;;-1:-1:-1;;18870:19:0;;;51705:16;:14;:16::i;:::-;19036:9;:7;:9::i;:::-;18912:11;:18;;-1:-1:-1;;18912:18:0;18926:4;18912:18;;;45676:54::o;8603:206::-;-1:-1:-1;;;;;8721:16:0;;;;;;;:9;:16;;;;;;;;:25;;;;;;;;;;;;;:33;;;8770:31;;;;;;;;;;;;;;;;;8603:206;;;:::o;20967:428::-;-1:-1:-1;;;;;21126:22:0;;;21099:24;21126:22;;;:15;:22;;;;;;;;:31;;;;;;;;;;;;;;21172:16;;;;:51;;;-1:-1:-1;;21192:16:0;:31;;21172:51;21168:220;;;21268:5;21248:16;:25;;21240:63;;;;;-1:-1:-1;;;21240:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;21318:22:0;;;;;;;:15;:22;;;;;;;;:31;;;;;;;;;21352:24;;;21318:58;;21168:220;20967:428;;;;:::o;18335:329::-;18455:10;;18290:34;;;;;;;;;;;;;;;;;18471:44;;-1:-1:-1;;;;;18471:44:0;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;18471:44:0;;;;;;25:18:-1;;;61:17;;-1:-1;;;;;182:15;-1:-1;;;179:29;160:49;;18455:61:0;;;;18407:12;;18421:17;;18455:10;;;:61;;;;25:18:-1;36:153;66:2;61:3;58:11;36:153;;176:10;;164:23;;-1:-1;;139:12;;;;98:2;89:12;;;;114;36:153;;;274:1;267:3;263:2;259:12;254:3;250:22;246:30;315:4;311:9;305:3;299:10;295:26;356:4;350:3;344:10;340:21;389:7;380;377:20;372:3;365:33;3:399;;;18455:61:0;;;;;;;;;;;;;;;;;;;;;;;;14:1:-1;21;16:31;;;;75:4;69:11;64:16;;144:4;140:9;133:4;115:16;111:27;107:43;104:1;100:51;94:4;87:65;169:16;166:1;159:27;225:16;222:1;215:4;212:1;208:12;193:49;7:242;;16:31;36:4;31:9;;7:242;;18406:110:0;;;;18549:7;:57;;;;-1:-1:-1;18561:11:0;;:16;;:44;;;18592:4;18581:24;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;18581:24:0;18561:44;18527:129;;;;;-1:-1:-1;;;18527:129:0;;;;;;;;;;;;-1:-1:-1;;;18527:129:0;;;;;;;;;;;;;;2848:471;2906:7;3151:6;3147:47;;-1:-1:-1;3181:1:0;3174:8;;3147:47;3218:5;;;3222:1;3218;:5;:1;3242:5;;;;;:10;3234:56;;;;-1:-1:-1;;;3234:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3310:1;2848:471;-1:-1:-1;;;2848:471:0:o;4506:132::-;4564:7;4591:39;4595:1;4598;4591:39;;;;;;;;;;;;;;;;;:3;:39::i;1094:181::-;1152:7;1184:5;;;1208:6;;;;1200:46;;;;;-1:-1:-1;;;1200:46:0;;;;;;;;;;;;;;;;;;;;;;;;;;;1987:137;2045:7;2072:44;2076:1;2079;2072:44;;;;;;;;;;;;;;;;;:3;:44::i;46632:2012::-;46799:27;46841:22;46878:21;46949:23;46963:8;46949:13;:23::i;:::-;46927:45;;47003:11;46987:12;:27;46983:109;;;-1:-1:-1;;47079:12:0;;47037:19;;-1:-1:-1;;;47079:12:0;;-1:-1:-1;;;;;47079:12:0;47029:63;;46983:109;47126:11;;-1:-1:-1;;;;;47126:11:0;47152:26;;;47148:1426;;;-1:-1:-1;;;;;47235:24:0;;47195:37;47235:24;;;:14;:24;;;;;47299:26;;;47357:39;:19;47299:26;47357:39;:23;:39;:::i;:::-;47340:56;;47438:23;47446:14;47438:7;:23::i;:::-;47411:50;;-1:-1:-1;;;;;;47411:50:0;-1:-1:-1;;;;;47411:50:0;;;;-1:-1:-1;;;;;;;;47476:43:0;-1:-1:-1;;;47476:43:0;;;;;;;;;;;:28;47558:12;47550:41;;47558:12;;;;47576:14;47550:25;:41::i;:::-;47534:57;;47621:22;47629:13;47621:7;:22::i;:::-;47606:12;;:37;;;;;-1:-1:-1;;;;;47606:37:0;;;;;-1:-1:-1;;;;;47606:37:0;;;;;;47148:1426;;;;;-1:-1:-1;;;;;47716:24:0;;47676:37;47716:24;;;:14;:24;;;;;47780:26;;;47838:36;;;:113;;47950:1;47838:113;;;47916:14;47894:19;:36;47838:113;47821:130;;47993:23;48001:14;47993:7;:23::i;:::-;47966:50;;-1:-1:-1;;;;;;47966:50:0;-1:-1:-1;;;;;47966:50:0;;;;;;;48035:19;48031:176;;48075:32;;-1:-1:-1;;;;;;;;48075:32:0;;;48031:176;;;48148:43;;-1:-1:-1;;;;;;;;48148:43:0;-1:-1:-1;;;;;;;;48148:43:0;;;;;;48031:176;48221:28;48269:39;:19;48293:14;48269:39;:23;:39;:::i;:::-;48339:12;;-1:-1:-1;;;48339:12:0;;-1:-1:-1;;;;;48339:12:0;;-1:-1:-1;48221:87:0;-1:-1:-1;48397:36:0;;;:113;;48509:1;48397:113;;;48469:20;48453:13;:36;48397:113;48381:129;;48540:22;48548:13;48540:7;:22::i;:::-;48525:12;;:37;;;;;-1:-1:-1;;;;;48525:37:0;;;;;-1:-1:-1;;;;;48525:37:0;;;;;;47148:1426;;;;48584:52;48597:8;48607:14;48623:12;-1:-1:-1;;;;;48584:52:0;:12;:52::i;:::-;46632:2012;;;;;;;;;:::o;44170:95::-;44209:15;:13;:15::i;:::-;44235:22;:20;:22::i;2413:192::-;2499:7;2535:12;2527:6;;;;2519:29;;;;-1:-1:-1;;;2519: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;2519:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;2571:5:0;;;2413:192::o;8817:323::-;8949:91;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;8949:15:0;;-1:-1:-1;8949:15:0;;;:9;:15;;;;;;;;:91;;8983:5;;8949:91;:19;:91;:::i;:::-;-1:-1:-1;;;;;8931:15:0;;;;;;;:9;:15;;;;;;:109;;;;9067:13;;;;;;;:24;;9085:5;9067:24;:17;:24;:::i;:::-;-1:-1:-1;;;;;9051:13:0;;;;;;;:9;:13;;;;;;;;;:40;;;;9107:25;;;;;;;9051:13;;9107:25;;;;;;;;;;;;;8817:323;;;:::o;30392:272::-;30519:13;:11;:13::i;:::-;30564:3;30551:9;:16;;30543:51;;;;;-1:-1:-1;;;30543:51:0;;;;;;;;;;;;-1:-1:-1;;;30543:51:0;;;;;;;;;;;;;;;30626:3;30613:9;:16;;30605:51;;;;;-1:-1:-1;;;30605:51:0;;;;;;;;;;;;-1:-1:-1;;;30605:51:0;;;;;;;;;;;;;;;30392:272;;;:::o;30672:127::-;30751:7;;;;;;;;;-1:-1:-1;;;;;30751:7:0;-1:-1:-1;;;;;30742:23:0;;:25;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30742:25:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30742:25:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;30742:25:0;-1:-1:-1;;;;;30728:39:0;:10;:39;30720:71;;;;;-1:-1:-1;;;30720:71:0;;;;;;;;;;;;-1:-1:-1;;;30720:71:0;;;;;;;;;;;;;;44273:930;44430:16;;44377:7;;44461:33;;;44457:738;;;44511:24;44555:172;44595:113;44681:4;44595:55;44636:13;;44595:36;44613:17;44595:13;:17;;:36;;;;:::i;:::-;:40;:55;:40;:55;:::i;:113::-;44555:13;;:172;:17;:172;:::i;:::-;44511:216;-1:-1:-1;44742:17:0;44779:111;44859:12;44779:53;44511:216;44779:31;44859:12;44796:13;44779:31;:16;:31;:::i;:111::-;44742:148;-1:-1:-1;44909:14:0;44905:40;;44932:13;44925:20;;;;;;;44905:40;44995:7;;44986:35;;;-1:-1:-1;;;44986:35:0;;;;44960:23;;-1:-1:-1;;;;;44995:7:0;;44986:33;;:35;;;;;;;;;;;;;;44995:7;44986:35;;;5:2:-1;;;;30:1;27;20:12;5:2;44986:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;44986:35:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;44986:35:0;;-1:-1:-1;45036:33:0;44986:35;45059:9;45036:5;:33::i;:::-;-1:-1:-1;;45084:16:0;:35;;;45103:16;-1:-1:-1;45134:23:0;;-1:-1:-1;45134:23:0;44457:738;45182:13;45175:20;;;;;7561:602;7643:12;;;;:4;;:12;;;;;:::i;:::-;-1:-1:-1;7666:16:0;;;;:6;;:16;;;;;:::i;:::-;-1:-1:-1;7854:135:0;;7754:7;;7854:135;;;;;;;;;;;;;;;;8008:23;;;;;;;8060:10;;;;;;;;-1:-1:-1;;;8060:10:0;;;;;;;7825:319;;;;;;;;;;;;;;;;8050:21;7825:319;;;;;;;;;;;8124:4;7825:319;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;7825:319:0;;;;;;;-1:-1:-1;7801:354:0;;;;;;;;7782:16;:373;-1:-1:-1;7561:602:0:o;8171:204::-;8247:11;;:22;;8263:5;8247:22;:15;:22;:::i;:::-;8233:11;:36;-1:-1:-1;;;;;8296:13:0;;;;;;:9;:13;;;;;;:24;;8314:5;8296:24;:17;:24;:::i;:::-;-1:-1:-1;;;;;8280:13:0;;;;;;:9;:13;;;;;;;;:40;;;;8336:31;;;;;;;8280:13;;;;8336:31;;;;;;;;;;8171:204;;:::o;42714:96::-;42766:6;42793:1;42789;:5;:13;;42801:1;42789:13;;;-1:-1:-1;42797:1:0;;42785:17;-1:-1:-1;42714:96:0:o;20542:224::-;-1:-1:-1;;;;;20666:22:0;;;;;;;:15;:22;;;;;;;;:31;;;;;;;;;;;;;:39;;;20721:37;;;;;;;;;;;;;;;;;20542:224;;;:::o;8383:212::-;-1:-1:-1;;;;;8465:15:0;;;;;;:9;:15;;;;;;:26;;8485:5;8465:26;:19;:26;:::i;:::-;-1:-1:-1;;;;;8447:15:0;;;;;;:9;:15;;;;;:44;8516:11;;:22;;8532:5;8516:22;:15;:22;:::i;:::-;8502:11;:36;8554:33;;;;;;;;8577:1;;-1:-1:-1;;;;;8554:33:0;;;;;;;;;;;;8383:212;;:::o;9885:1052::-;10143:15;10131:8;:27;;10123:54;;;;;-1:-1:-1;;;10123:54:0;;;;;;;;;;;;-1:-1:-1;;;10123:54:0;;;;;;;;;;;;;;;10318:16;;-1:-1:-1;;;;;10583:13:0;;;10188:14;10583:13;;;:6;:13;;;;;;;;:15;;;;;;;;;10393:271;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;10393:271:0;;;;;10357:330;;;;;;-1:-1:-1;;;10246:460:0;;;;;;;;;;;;;;;;;;;;;26:21:-1;;;22:32;;;6:49;;10246:460:0;;;;;;10218:503;;;;;;;;;10759:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10188:14;;10583:15;10759:26;;;;;-1:-1:-1;;10759:26:0;;;;;;;;;;10583:15;10759:26;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;10759:26:0;;-1:-1:-1;;10759:26:0;;;-1:-1:-1;;;;;;;10818:30:0;;;;;;:59;;;10872:5;-1:-1:-1;;;;;10852:25:0;:16;-1:-1:-1;;;;;10852:25:0;;10818:59;10796:133;;;;;-1:-1:-1;;;10796:133:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;9885:1052;;;;;;;;;;:::o;20147:144::-;20198:7;-1:-1:-1;;;20226:1:0;:10;20218:37;;;;;-1:-1:-1;;;20218:37:0;;;;;;;;;;;;-1:-1:-1;;;20218:37:0;;;;;;;;;;;;;;;-1:-1:-1;20281:1:0;20147:144::o;46244:380::-;46409:13;;-1:-1:-1;;;;;46409:13:0;46437:28;46433:41;;46467:7;;;46433:41;46484:132;;;-1:-1:-1;;;46484:132:0;;-1:-1:-1;;;;;46484:132:0;;;;;;;;;;;;;;;;;;;;;:42;;;;;;:132;;;;;-1:-1:-1;;46484:132:0;;;;;;;;-1:-1:-1;46484:42:0;:132;;;5:2:-1;;;;30:1;27;20:12;5:2;46484:132:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;46484:132:0;;;;46244:380;;;;:::o;5126:345::-;5212:7;5314:12;5307:5;5299:28;;;;-1:-1:-1;;;5299:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27:10:-1;;8:100;;90:11;;;84:18;71:11;;;64:39;52:2;45:10;8:100;;5299:28:0;;5338:9;5354:1;5350;:5;;;;;;;5126:345;-1:-1:-1;;;;;5126:345:0:o;15852:139::-;15913:10;;15906:43;;;-1:-1:-1;;;15906:43:0;;15943:4;15906:43;;;;;;-1:-1:-1;;;;;15913:10:0;;;;15906:28;;:43;;;;;;;;;;;;;;;15913:10;15906:43;;;5:2:-1;;;;30:1;27;20:12;5:2;15906:43:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;15906:43:0;;;;;;;13:2:-1;8:3;5:11;2:2;;;29:1;26;19:12;2:2;-1:-1;15906:43:0;15891:12;:58;;;15965:18;;;;;;;;;;;;15906:43;15965:18;;;15852:139::o;22824:2237::-;22898:19;;22944:11;;22979:10;;;;;;;-1:-1:-1;;;23018:14:0;;;;;;-1:-1:-1;;;23067:19:0;;;;22870:25;23067:19;23171;:17;:19::i;:::-;:42;;-1:-1:-1;23245:15:0;;;;23242:928;;23290:19;:17;:19::i;:::-;23268;;:41;;;;;;;;;;;;;;;;;;23315:17;23361:15;23347:11;:29;23343:460;;;23437:8;23536:4;23522:11;23448:85;;23507:12;23489:15;23467:11;23449:15;:29;23482:4;23448:38;:56;;;;;;:71;:85;:92;;;;;;23437:103;;23568:4;23562:3;:10;:27;;23586:3;23579:4;:10;23562:27;;;23575:1;23562:27;23547:42;;23343:460;;;;23661:8;23760:4;23746:11;23672:85;;23731:12;23713:15;23687;23673:11;:29;23706:4;23672:38;:56;;;;;;:71;:85;:92;;;;;;23792:4;23786:10;;-1:-1:-1;;23343:460:0;23887:4;23854:30;;;:37;23836:55;;22525:12;23900:15;:38;23897:81;;;22525:12;23940:38;;23897:81;22601:12;23987:15;:38;23984:81;;;22601:12;24027:38;;23984:81;24073:14;:40;;-1:-1:-1;;24073:40:0;-1:-1:-1;;;24073:40:0;;;;;;;24124;;;;;;;;;;;;;;;;;;23242:928;;24253:12;;24307;;24178:21;;-1:-1:-1;;;24253:12:0;;-1:-1:-1;;;;;24253:12:0;;24178:21;;24307:31;;24253:12;24307:16;:31::i;:::-;24285:53;-1:-1:-1;24363:19:0;;24362:65;;24413:14;24390:13;24406:4;24390:20;:37;;;;;;24362:65;;;24386:1;24362:65;24343:84;;22824:2237;;24518:20;24498:16;:40;24495:483;;24653:20;24634:16;24616:15;:34;:57;;;;;;24602:71;;24495:483;;;24753:20;24835;24828:4;:27;24796:20;24777:16;:39;24820:4;24776:48;:80;;;;;;;-1:-1:-1;24968:4:0;24901:19;24900:39;;:46;;24899:66;;:73;24885:87;;24495:483;;24982:10;:32;;-1:-1:-1;;24982:32:0;;;;;;;25024;;;;;;;;;;;;;;;;;;22824:2237;;;;;;;:::o;43326:8418::-;;;;;;;;;;-1:-1:-1;43326:8418:0;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43326:8418:0;;;;-1:-1:-1;43326:8418:0;;;;;;;;;;;;;;

Swarm Source

bzzr://23fb3858826e70547859ad9f710fa44fe1adaa923b59a3fe8c783867c21f2ac8