/**
 *Submitted for verification at uniscan.xyz on 2025-07-01
*/

// 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\ImpermaxERC20.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 ImpermaxERC20 {
	using SafeMath for uint;
	
	string public name;
	string public symbol;
	uint8 public decimals = 18;
	uint public totalSupply;
	mapping(address => uint) public balanceOf;
	mapping(address => mapping(address => uint)) public allowance;
	
	bytes32 public DOMAIN_SEPARATOR;
	mapping(address => uint) public nonces;
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint value);

	constructor() public {}	
	
	function _setName(string memory _name, string memory _symbol) internal {
		name = _name;
		symbol = _symbol;
		uint 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, uint value) internal {
		totalSupply = totalSupply.add(value);
		balanceOf[to] = balanceOf[to].add(value);
		emit Transfer(address(0), to, value);
	}

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

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

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

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

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

	function transferFrom(address from, address to, uint value) external returns (bool) {
		if (allowance[from][msg.sender] != uint(-1)) {
			allowance[from][msg.sender] = allowance[from][msg.sender].sub(value, "Impermax: TRANSFER_NOT_ALLOWED");
		}
		_transfer(from, to, value);
		return true;
	}
	
	function _checkSignature(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s, bytes32 typehash) internal {
		require(deadline >= block.timestamp, "Impermax: 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, "Impermax: 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, uint value, uint 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\IPoolToken.sol

pragma solidity >=0.5.0;

interface IPoolToken {

	/*** Impermax ERC20 ***/
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint 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 (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);
	
	function DOMAIN_SEPARATOR() external view returns (bytes32);
	function PERMIT_TYPEHASH() external pure returns (bytes32);
	function nonces(address owner) external view returns (uint);
	function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
	
	/*** Pool Token ***/
	
	event Mint(address indexed sender, address indexed minter, uint mintAmount, uint mintTokens);
	event Redeem(address indexed sender, address indexed redeemer, uint redeemAmount, uint redeemTokens);
	event Sync(uint totalBalance);
	
	function underlying() external view returns (address);
	function factory() external view returns (address);
	function totalBalance() external view returns (uint);
	function MINIMUM_LIQUIDITY() external pure returns (uint);

	function exchangeRate() external returns (uint);
	function mint(address minter) external returns (uint mintTokens);
	function redeem(address redeemer) external returns (uint redeemAmount);
	function skim(address to) external;
	function sync() external;
	
	function _setFactory() external;
}

// File: contracts\libraries\SafeToken.sol

pragma solidity =0.5.16;

interface ERC20Interface {
    function balanceOf(address user) external view returns (uint256);
}

library SafeToken {
    function myBalance(address token) internal view returns (uint256) {
        return ERC20Interface(token).balanceOf(address(this));
    }

    function balanceOf(address token, address user) internal view returns (uint256) {
        return ERC20Interface(token).balanceOf(user);
    }

    function safeApprove(address token, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('approve(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x095ea7b3, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeApprove");
    }

    function safeTransfer(address token, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('transfer(address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0xa9059cbb, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransfer");
    }

    function safeTransferFrom(address token, address from, address to, uint256 value) internal {
        // bytes4(keccak256(bytes('transferFrom(address,address,uint256)')));
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(0x23b872dd, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), "!safeTransferFrom");
    }

    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call.value(value)(new bytes(0));
        require(success, "!safeTransferETH");
    }
}

// File: contracts\PoolToken.sol

pragma solidity =0.5.16;
contract PoolToken is IPoolToken, ImpermaxERC20 {
	using SafeToken for address;
	
   	uint internal constant initialExchangeRate = 1e18;
	address public underlying;
	address public factory;
	uint public totalBalance;
	uint public constant MINIMUM_LIQUIDITY = 1000;
	
	event Mint(address indexed sender, address indexed minter, uint mintAmount, uint mintTokens);
	event Redeem(address indexed sender, address indexed redeemer, uint redeemAmount, uint redeemTokens);
	event Sync(uint totalBalance);
	
	/*** Initialize ***/
	
	// called once by the factory
	function _setFactory() external {
		require(factory == address(0), "Impermax: FACTORY_ALREADY_SET");
		factory = msg.sender;
	}
	
	/*** PoolToken ***/
	
	function _update() internal {
		totalBalance = underlying.myBalance();
		emit Sync(totalBalance);
	}

	function exchangeRate() public returns (uint) 
	{
		uint _totalSupply = totalSupply; // gas savings
		uint _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 (uint mintTokens) {
		uint balance = underlying.myBalance();
		uint 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, "Impermax: 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 (uint redeemAmount) {
		uint redeemTokens = balanceOf[address(this)];
		redeemAmount = redeemTokens.mul(exchangeRate()).div(1e18);

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

	// force real balance to match totalBalance
	function skim(address to) external nonReentrant {
		underlying.safeTransfer(to, underlying.myBalance().sub(totalBalance));
	}

	// force totalBalance to match real balance
	function sync() external nonReentrant update {}
	
	/*** Utilities ***/
	
	// prevents a contract from calling itself, directly or indirectly.
	bool internal _notEntered = true;
	modifier nonReentrant() {
		require(_notEntered, "Impermax: REENTERED");
		_notEntered = false;
		_;
		_notEntered = true;
	}
	
	// update totalBalance with current balance
	modifier update() {
		_;
		_update();
	}
}

// File: contracts\LVStorageV2.sol

pragma solidity =0.5.16;

contract LVStorageV2 {
	address[] public borrowables;
	struct BorrowableInfo {
		bool enabled;
		bool exists;
	}
	mapping(address => BorrowableInfo) public borrowableInfo;
	function getBorrowablesLength() external view returns (uint) {
		return borrowables.length;
	}
	function indexOfBorrowable(address borrowable) public view returns (uint) {
		for (uint i = 0; i < borrowables.length; i++) {
			if (borrowables[i] == borrowable) {
				return i;
			}
		}
		require(false, "LendingVaultV2: BORROWABLE_NOT_FOUND");
	}

	uint public exchangeRateLast;

	uint public reserveFactor = 0.00e18; //0%
}

// File: contracts\interfaces\ILendingVaultV2.sol

pragma solidity >=0.5.0;

interface ILendingVaultV2 {

	/*** Impermax ERC20 ***/
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint 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 (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);
	
	function DOMAIN_SEPARATOR() external view returns (bytes32);
	function PERMIT_TYPEHASH() external pure returns (bytes32);
	function nonces(address owner) external view returns (uint);
	function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
	
	/*** Pool Token ***/
	
	event Mint(address indexed sender, address indexed minter, uint mintAmount, uint mintTokens);
	event Redeem(address indexed sender, address indexed redeemer, uint redeemAmount, uint redeemTokens);
	event Sync(uint totalBalance);
	
	function underlying() external view returns (address);
	function factory() external view returns (address);
	function totalBalance() external view returns (uint);
	function MINIMUM_LIQUIDITY() external pure returns (uint);

	function exchangeRate() external returns (uint);
	function mint(address minter) external returns (uint mintTokens);
	function redeem(address redeemer) external returns (uint redeemAmount);
	function skim(address to) external;
	function sync() external;
	
	function _setFactory() external;
	
	/*** Lending Vault V2 ***/
	
	event AddBorrowable(address indexed borrowable);
	event RemoveBorrowable(address indexed borrowable);
	event EnableBorrowable(address indexed borrowable);
	event DisableBorrowable(address indexed borrowable);
	event UnwindBorrowable(address indexed borrowable, uint256 underlyingBalance, uint256 actualRedeemAmount);
	event AllocateIntoBorrowable(address indexed borrowable, uint256 mintAmount, uint256 mintTokens);
	event DeallocateFromBorrowable(address indexed borrowable, uint256 redeemAmount, uint256 redeemTokens);

	function borrowables(uint) external view returns (address borrowable);
	function borrowableInfo(address borrowable) external view returns (
		bool enabled,
		bool exists
	);
	function getBorrowablesLength() external view returns (uint);
	function indexOfBorrowable(address borrowable) external view returns (uint);

	function reserveFactor() external view returns (uint);
	function exchangeRateLast() external view returns (uint);
	
	function addBorrowable(address borrowable) external;
	function removeBorrowable(address borrowable) external;
	function disableBorrowable(address borrowable) external;
	function enableBorrowable(address borrowable) external;
	function unwindBorrowable(address borrowable) external;
	
	function reallocate() external;
		
	/*** Lending Vault Setter ***/

	event NewReserveFactor(uint newReserveFactor);

	function RESERVE_FACTOR_MAX() external pure returns (uint);
	
	function _initialize (
		address _underlying,
		string calldata _name,
		string calldata _symbol
	) external;
	function _setReserveFactor(uint newReserveFactor) external;
}

// File: contracts\interfaces\IBorrowable.sol

pragma solidity >=0.5.0;

interface IBorrowable {

	/*** Impermax ERC20 ***/
	
	event Transfer(address indexed from, address indexed to, uint value);
	event Approval(address indexed owner, address indexed spender, uint 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 (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);
	
	function DOMAIN_SEPARATOR() external view returns (bytes32);
	function PERMIT_TYPEHASH() external pure returns (bytes32);
	function nonces(address owner) external view returns (uint);
	function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
	
	/*** Pool Token ***/
	
	event Mint(address indexed sender, address indexed minter, uint mintAmount, uint mintTokens);
	event Redeem(address indexed sender, address indexed redeemer, uint redeemAmount, uint redeemTokens);
	event Sync(uint totalBalance);
	
	function underlying() external view returns (address);
	function factory() external view returns (address);
	function totalBalance() external view returns (uint);
	function MINIMUM_LIQUIDITY() external pure returns (uint);

	function exchangeRate() external returns (uint);
	function mint(address minter) external returns (uint mintTokens);
	function redeem(address redeemer) external returns (uint redeemAmount);
	function skim(address to) external;
	function sync() external;
	
	function _setFactory() external;
	
	/*** Borrowable ***/

	event BorrowApproval(address indexed owner, address indexed spender, uint value);
	
	function collateral() external view returns (address);
	function reserveFactor() external view returns (uint);
	function exchangeRateLast() external view returns (uint);
	function borrowIndex() external view returns (uint);
	function totalBorrows() external view returns (uint);
	function borrowAllowance(address owner, address spender) external view returns (uint);
	
	function BORROW_PERMIT_TYPEHASH() external pure returns (bytes32);
	function borrowApprove(address spender, uint256 value) external returns (bool);
	function borrowPermit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

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

	event AccrueInterest(uint interestAccumulated, uint borrowIndex, uint totalBorrows);
	event CalculateKink(uint kinkRate);
	event CalculateBorrowRate(uint borrowRate);
	
	function KINK_BORROW_RATE_MAX() external pure returns (uint);
	function KINK_BORROW_RATE_MIN() external pure returns (uint);
	function KINK_MULTIPLIER() external pure returns (uint);
	function borrowRate() external view returns (uint);
	function kinkBorrowRate() external view returns (uint);
	function kinkUtilizationRate() external view returns (uint);
	function adjustSpeed() external view returns (uint);
	function rateUpdateTimestamp() external view returns (uint32);
	function accrualTimestamp() external view returns (uint32);
	
	function accrueInterest() external;
	
	/*** Borrowable Setter ***/

	event NewReserveFactor(uint newReserveFactor);
	event NewKinkUtilizationRate(uint newKinkUtilizationRate);
	event NewAdjustSpeed(uint newAdjustSpeed);

	function RESERVE_FACTOR_MAX() external pure returns (uint);
	function KINK_UR_MIN() external pure returns (uint);
	function KINK_UR_MAX() external pure returns (uint);
	function ADJUST_SPEED_MIN() external pure returns (uint);
	function ADJUST_SPEED_MAX() external pure returns (uint);
	
	function _initialize (
		string calldata _name, 
		string calldata _symbol,
		address _underlying, 
		address _collateral
	) external;
	function _setReserveFactor(uint newReserveFactor) external;
	function _setKinkUtilizationRate(uint newKinkUtilizationRate) external;
	function _setAdjustSpeed(uint newAdjustSpeed) external;
}

// 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\libraries\BorrowableHelpers.sol

pragma solidity =0.5.16;
library BorrowableHelpers {
	using SafeMath for uint256;

	function underlyingValueOf(address borrowable, uint256 borrowableAmount) internal returns (uint256) {
		uint256 exchangeRate = IBorrowable(borrowable).exchangeRate();
		return borrowableAmount.mul(exchangeRate).div(1e18);
	}

	function underlyingBalanceOf(address borrowable, address account) internal returns (uint256) {
		return underlyingValueOf(borrowable, IBorrowable(borrowable).balanceOf(account));
	}

	function myUnderlyingBalance(address borrowable) internal returns (uint256) {
		return underlyingValueOf(borrowable, IBorrowable(borrowable).balanceOf(address(this)));
	}
	
	/*** AMOUNT TO TOKENS CONVERSION ***/
		
	function tokensFor(uint redeemAmount, uint exchangeRate, bool atMost) internal pure returns (uint redeemTokens) {
		uint redeemTokensLow = redeemAmount.mul(1e18).div(exchangeRate);
		uint redeemTokensHigh = redeemTokensLow.add(1);
		
		if (atMost) {
			uint actualRedeemAmountHigh = redeemTokensHigh.mul(exchangeRate).div(1e18);
			return actualRedeemAmountHigh <= redeemAmount ? redeemTokensHigh : redeemTokensLow;
		} else {
			uint actualRedeemAmountLow = redeemTokensLow.mul(exchangeRate).div(1e18);
			return actualRedeemAmountLow >= redeemAmount ? redeemTokensLow : redeemTokensHigh;
		}
	}
	
	function tokensForAtMost(uint redeemAmount, uint exchangeRate) internal pure returns (uint redeemTokens) {
		return tokensFor(redeemAmount, exchangeRate, true);
	}
	
	function tokensForAtLeast(uint redeemAmount, uint exchangeRate) internal pure returns (uint redeemTokens) {
		return tokensFor(redeemAmount, exchangeRate, false);
	}
}

// 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\libraries\BorrowableObject.sol

pragma solidity =0.5.16;
pragma experimental ABIEncoderV2;
library BorrowableObject {
	using SafeMath for uint;
	using BorrowableObject for Borrowable;

	struct Borrowable {
		IBorrowable borrowableContract;
		uint exchangeRate;
		uint totalBorrows;       // in underlyings
		uint externalSupply;     // in underlyings
		uint initialOwnedSupply; // in underlyings
		uint ownedSupply;        // in underlyings
		uint kinkBorrowRate;
		uint kinkUtilizationRate;
		uint reserveFactor;
		uint kinkMultiplier;
		uint cachedSupplyRate;
	}

	function newBorrowable(IBorrowable borrowableContract, address lendingVault) internal returns (Borrowable memory borrowable) {
		borrowableContract.sync();
		uint exchangeRate = borrowableContract.exchangeRate();
		uint totalSupplyInTokens = borrowableContract.totalSupply();
		uint ownedSupplyInTokens = borrowableContract.balanceOf(lendingVault);
		uint externalSupplyInTokens = totalSupplyInTokens.sub(ownedSupplyInTokens);
		borrowable = Borrowable({
			borrowableContract: borrowableContract,
			exchangeRate: exchangeRate,
			totalBorrows: borrowableContract.totalBorrows(),
			externalSupply: externalSupplyInTokens.mul(exchangeRate).div(1e18),
			initialOwnedSupply: ownedSupplyInTokens.mul(exchangeRate).div(1e18),
			ownedSupply: ownedSupplyInTokens.mul(exchangeRate).div(1e18),
			kinkBorrowRate: borrowableContract.kinkBorrowRate(),
			kinkUtilizationRate: borrowableContract.kinkUtilizationRate(),
			reserveFactor: borrowableContract.reserveFactor(),
			kinkMultiplier: borrowableContract.KINK_MULTIPLIER(),
			cachedSupplyRate: 0
		});
		borrowable.cachedSupplyRate = supplyRate(borrowable);
		return borrowable;
	}

	function totalSupply(Borrowable memory borrowable) internal pure returns (uint) {
		return borrowable.externalSupply.add(borrowable.ownedSupply);
	}

	function utilizationRate(Borrowable memory borrowable) internal pure returns (uint) {
		uint _totalSupply = totalSupply(borrowable);
		if (_totalSupply == 0) return 0;
		return borrowable.totalBorrows.mul(1e18).div(_totalSupply);
	}

	function kinkRate(Borrowable memory borrowable) internal pure returns (uint) {
		return borrowable.kinkUtilizationRate
			.mul(borrowable.kinkBorrowRate).div(1e18)
			.mul(uint(1e18).sub(borrowable.reserveFactor)).div(1e18);
	}

	function supplyRate(Borrowable memory borrowable) internal pure returns (uint rate) {
		uint utilizationRate_ = utilizationRate(borrowable);
		uint ratio = utilizationRate_.mul(1e18).div(borrowable.kinkUtilizationRate);
		uint borrowFactor; //borrowRate to kinkBorrowRate ratio
		if (utilizationRate_ < borrowable.kinkUtilizationRate) {
			borrowFactor = ratio;
		} else {
			uint excessRatio = utilizationRate_.sub(borrowable.kinkUtilizationRate)
				.mul(1e18).div(uint(1e18).sub(borrowable.kinkUtilizationRate));
			borrowFactor = excessRatio.mul(borrowable.kinkMultiplier.sub(1)).add(1e18);
		}
		rate = borrowFactor.mul(kinkRate(borrowable)).div(1e18).mul(ratio).div(1e18);
	}

	function allocate(Borrowable memory borrowable, uint amount) internal pure returns (Borrowable memory) {
		borrowable.ownedSupply = borrowable.ownedSupply.add(amount);
		borrowable.cachedSupplyRate = supplyRate(borrowable);
		return borrowable;
	}

	function deallocate(Borrowable memory borrowable, uint amount) internal pure returns (Borrowable memory) {
		uint availableLiquidity = totalSupply(borrowable).sub(borrowable.totalBorrows, "ERROR: NEGATIVE AVAILABLE LIQUIDITY");
		require(amount <= availableLiquidity, "ERROR: DEALLOCATE AMOUNT > AVAILABLE LIQUIDITY");
		borrowable.ownedSupply = borrowable.ownedSupply.sub(amount);
		borrowable.cachedSupplyRate = supplyRate(borrowable);
		return borrowable;
	}

	function deallocateMax(Borrowable memory borrowable) internal pure returns (Borrowable memory, uint) {
		if (totalSupply(borrowable) < borrowable.totalBorrows) return (borrowable, 0);
		uint availableLiquidity = totalSupply(borrowable).sub(borrowable.totalBorrows);
		uint amount = Math.min(borrowable.ownedSupply, availableLiquidity);
		return (deallocate(borrowable, amount), amount);
	}

	function calculateUtilizationForRate(Borrowable memory borrowable, uint rate) internal pure returns (uint targetUtilizationRate) {
		if (rate <= kinkRate(borrowable)) {
			targetUtilizationRate = Math.sqrt(
				rate.mul(1e18).div(kinkRate(borrowable)).mul(1e18)
			).mul(borrowable.kinkUtilizationRate).div(1e18);
		} else {
			uint a = borrowable.kinkMultiplier.sub(1);
			uint b = borrowable.kinkUtilizationRate.mul(borrowable.kinkMultiplier).sub(1e18);
			uint c = rate.mul(borrowable.kinkUtilizationRate).div(1e18)
				.mul(uint(1e18).sub(borrowable.kinkUtilizationRate)).div(kinkRate(borrowable));
			uint tmp = Math.sqrt(
				b.mul(b).div(1e18).add(a.mul(c).mul(4)).mul(1e18)
			);
			targetUtilizationRate = tmp.add(b).div(a).div(2);
		}
	}

	function calculateAmountForRate(Borrowable memory borrowable, uint rate) internal pure returns (uint) {
		require(rate > 0, "ERROR: rate = 0");
		require(rate <= borrowable.cachedSupplyRate, "ERROR: TARGET RATE > CACHED RATE");
		uint targetUtilizationRate = calculateUtilizationForRate(borrowable, rate);
		uint targetSupply = borrowable.totalBorrows.mul(1e18).div(targetUtilizationRate);
		if (targetSupply < totalSupply(borrowable)) {
			// catch any edge scenarios...
			return 0;
		}
		return targetSupply.sub(totalSupply(borrowable));
	}

	function compare(Borrowable memory borrowableA, Borrowable memory borrowableB) internal pure returns (bool) {
		return borrowableA.cachedSupplyRate > borrowableB.cachedSupplyRate;
	}
}

// File: contracts\LVAllocatorV2.sol

pragma solidity =0.5.16;
contract LVAllocatorV2 is ILendingVaultV2, PoolToken, LVStorageV2 {
	using BorrowableHelpers for address;
	using BorrowableObject for BorrowableObject.Borrowable;
	
	function _allocate(IBorrowable borrowable, uint mintAmount, uint _exchangeRate) internal returns (uint mintTokens) {
		mintTokens = mintAmount.mul(1e18).div(_exchangeRate);
		if (mintTokens == 0) return 0;
		underlying.safeTransfer(address(borrowable), mintAmount);
		mintTokens = borrowable.mint(address(this));

		emit AllocateIntoBorrowable(address(borrowable), mintAmount, mintTokens);
	}
	function _allocate(IBorrowable borrowable, uint mintAmount) internal returns (uint mintTokens) {
		mintTokens = _allocate(borrowable, mintAmount, borrowable.exchangeRate());
	}

	function _deallocate(IBorrowable borrowable, uint redeemTokens, uint _exchangeRate) internal returns (uint redeemAmount) {
		redeemAmount = redeemTokens.mul(_exchangeRate).div(1e18);
		if (redeemAmount == 0) return 0;
		uint totalBalance = borrowable.totalBalance();
		if (redeemAmount > totalBalance) {
			redeemTokens = totalBalance.mul(1e18).div(_exchangeRate);
		}
		address(borrowable).safeTransfer(address(borrowable), redeemTokens);
		redeemAmount = borrowable.redeem(address(this));

		emit DeallocateFromBorrowable(address(borrowable), redeemAmount, redeemTokens);
	}
	function _deallocate(IBorrowable borrowable, uint redeemTokens) internal returns (uint redeemAmount) {
		redeemAmount = _deallocate(borrowable, redeemTokens, borrowable.exchangeRate());
	}
	
	function _deallocateAtLeastOrMax(IBorrowable borrowable, uint redeemAmount, uint _exchangeRate) internal returns (uint actualRedeemAmount) {
		actualRedeemAmount = _deallocate(IBorrowable(borrowable), BorrowableHelpers.tokensForAtLeast(redeemAmount, _exchangeRate), _exchangeRate);
	}
	function _deallocateAtLeastOrMax(IBorrowable borrowable, uint redeemAmount) internal returns (uint actualRedeemAmount) {
		actualRedeemAmount = _deallocateAtLeastOrMax(borrowable, redeemAmount, borrowable.exchangeRate());
	}

	function _withdrawAndReallocate(uint withdrawAmount) internal {
		// initialize borrowablesObj
		BorrowableObject.Borrowable[] memory borrowablesObj = new BorrowableObject.Borrowable[](borrowables.length);
		uint borrowablesLength = borrowables.length;
		for(uint i = 0; i < borrowables.length; i++) {
			if (!borrowableInfo[borrowables[i]].enabled) {
				borrowablesLength--;
				continue;
			}
			uint delta = uint(borrowables.length).sub(borrowablesLength);
			borrowablesObj[i - delta] = BorrowableObject.newBorrowable(IBorrowable(borrowables[i]), address(this));
		}
		
		// deallocate everything
		uint amountToAllocate = underlying.myBalance();
		for(uint i = 0; i < borrowablesLength; i++) {
			uint amount;
			(borrowablesObj[i], amount) = borrowablesObj[i].deallocateMax();
			amountToAllocate = amountToAllocate.add(amount);
		}
		amountToAllocate = amountToAllocate.sub(withdrawAmount, "LendingVaultV2: INSUFFICIENT_LIQUIDITY");
		if (borrowablesLength == 0) return;
		
		// bubblesort borrowablesObj
		for (uint i = 0; i < borrowablesLength - 1; i++) {
			for (uint j = 0; j < borrowablesLength - 1 - i; j++) {
				if (!borrowablesObj[j].compare(borrowablesObj[j+1])) {
					BorrowableObject.Borrowable memory tmp = borrowablesObj[j];
					borrowablesObj[j] = borrowablesObj[j+1];
					borrowablesObj[j+1] = tmp;
				}
			}
		}

		// Allocate in the pool with the highest APR an amount such that the next APR matches the one
		// of the pool with the second highest APR.
		// Repeat until all the pools with the highest APR have the same APR.
		uint lastCycle = borrowablesLength;
		for(uint i = 1; i < borrowablesLength; i++) {
			uint targetRate = borrowablesObj[i].cachedSupplyRate;
			uint amountThisCycle = 0;
			uint[] memory amounts = new uint[](i);
			if (targetRate == 0) {
				// Unachievable APR
				lastCycle = i;
				break;
			}
			for (uint j = 0; j < i; j++) {
				if (borrowablesObj[j].cachedSupplyRate <= targetRate) break;
				amounts[j] = borrowablesObj[j].calculateAmountForRate(targetRate);
				amountThisCycle = amountThisCycle.add(amounts[j]);
			}
			if (amountThisCycle > amountToAllocate) {
				// We can't afford to complete this cycle
				lastCycle = i;
				break;
			}
			for (uint j = 0; j < i; j++) {
				if (amounts[j] == 0) continue;
				borrowablesObj[j] = borrowablesObj[j].allocate(amounts[j]);
				amountToAllocate = amountToAllocate.sub(amounts[j]);
			}
		}

		// distribute the amount left equally among pools with highest APR proportionally to their total supply
		uint globalTotalSupply = 0;
		uint totalAmountToAllocate = amountToAllocate;
		for (uint i = 0; i < lastCycle; i++) {
			globalTotalSupply = globalTotalSupply.add(borrowablesObj[i].totalSupply());
		}
		for (uint i = 0; i < lastCycle; i++) {
			uint amount = globalTotalSupply > 0 
				? borrowablesObj[i].totalSupply().mul(totalAmountToAllocate).div(globalTotalSupply)
				: amountToAllocate;
			if (amount > amountToAllocate) amount = amountToAllocate;
			borrowablesObj[i] = borrowablesObj[i].allocate(amount);
			amountToAllocate = amountToAllocate.sub(amount);
		}
		
		// redeem
		for(uint i = 0; i < borrowablesLength; i++) {
			if (borrowablesObj[i].ownedSupply < borrowablesObj[i].initialOwnedSupply) {
				uint redeemAmount = borrowablesObj[i].initialOwnedSupply.sub(borrowablesObj[i].ownedSupply);
				_deallocateAtLeastOrMax(borrowablesObj[i].borrowableContract, redeemAmount, borrowablesObj[i].exchangeRate);
			}
		}
		// mint
		amountToAllocate = underlying.myBalance().sub(withdrawAmount, "LendingVaultV2: NEGATIVE AMOUNT TO ALLOCATE");
		for(uint i = 0; i < borrowablesLength; i++) {
			if (borrowablesObj[i].ownedSupply > borrowablesObj[i].initialOwnedSupply) {
				uint mintAmount = borrowablesObj[i].ownedSupply.sub(borrowablesObj[i].initialOwnedSupply);
				if (mintAmount > amountToAllocate) mintAmount = amountToAllocate;
				amountToAllocate = amountToAllocate.sub(mintAmount);
				_allocate(borrowablesObj[i].borrowableContract, mintAmount, borrowablesObj[i].exchangeRate);
			}
		}
	}
}

// File: contracts\interfaces\ILendingVaultV2Factory.sol

pragma solidity >=0.5.0;

interface ILendingVaultV2Factory {
	event VaultCreated(address indexed underlying, address vault, uint);
	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 allVaults(uint) external view returns (address);
	function allVaultsLength() external view returns (uint);

	function createVault(address underlying, string calldata _name, string calldata _symbol) external returns (address vault);

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

// File: contracts\LVSetterV2.sol

pragma solidity =0.5.16;
contract LVSetterV2 is LVAllocatorV2 {

	uint public constant RESERVE_FACTOR_MAX = 0.90e18; //90%
	uint private constant MAX_BORROWABLES_LENGTH = 10;

	function _initialize(
		address _underlying,
		string calldata _name,
		string calldata _symbol
	) external {
		require(msg.sender == factory, "LendingVaultV2: UNAUTHORIZED"); // sufficient check
		_setName(_name, _symbol);
		underlying = _underlying;
		exchangeRateLast = initialExchangeRate;
	}
	
	function _setReserveFactor(uint newReserveFactor) external onlyAdmin nonReentrant {
		require(newReserveFactor <= RESERVE_FACTOR_MAX, "LendingVaultV2: INVALID_SETTING");
		reserveFactor = newReserveFactor;
		emit NewReserveFactor(newReserveFactor);
	}
	
	/*** Borrowables management ***/

	function addBorrowable(address borrowable) external onlyAdmin nonReentrant {
		require(IBorrowable(borrowable).underlying() == underlying, "LendingVaultV2: INVALID_UNDERLYING");
		require(!borrowableInfo[borrowable].exists, "LendingVaultV2: BORROWABLE_EXISTS");
		require(borrowables.length < MAX_BORROWABLES_LENGTH, "LendingVaultV2: MAX_BORROWABLES_LENGTH");

		borrowableInfo[borrowable].exists = true;
		borrowableInfo[borrowable].enabled = true;
		borrowables.push(borrowable);

		emit AddBorrowable(address(borrowable));
	}

	function removeBorrowable(address borrowable) external onlyAdmin nonReentrant {
		require(borrowableInfo[borrowable].exists, "LendingVaultV2: BORROWABLE_DOESNT_EXISTS");
		require(!borrowableInfo[borrowable].enabled, "LendingVaultV2: BORROWABLE_ENABLED");
		require(borrowable.myUnderlyingBalance() == 0, "LendingVaultV2: NOT_EMPTY");

		uint lastIndex = borrowables.length - 1;
		uint index = indexOfBorrowable(borrowable);

		borrowables[index] = borrowables[lastIndex];
		borrowables.pop();
		delete borrowableInfo[borrowable];

		emit RemoveBorrowable(address(borrowable));
	}

	function disableBorrowable(address borrowable) external onlyAdmin nonReentrant {
		require(borrowableInfo[borrowable].exists, "LendingVaultV2: BORROWABLE_DOESNT_EXISTS");
		require(borrowableInfo[borrowable].enabled, "LendingVaultV2: BORROWABLE_DISABLED");

		borrowableInfo[borrowable].enabled = false;

		emit DisableBorrowable(address(borrowable));
	}

	function enableBorrowable(address borrowable) external onlyAdmin nonReentrant {
		require(borrowableInfo[borrowable].exists, "LendingVaultV2: BORROWABLE_DOESNT_EXISTS");
		require(!borrowableInfo[borrowable].enabled, "LendingVaultV2: BORROWABLE_ENABLED");

		borrowableInfo[borrowable].enabled = true;

		emit EnableBorrowable(address(borrowable));
	}

	function unwindBorrowable(address borrowable) external onlyAdmin nonReentrant update {
		require(borrowableInfo[borrowable].exists, "LendingVaultV2: BORROWABLE_DOESNT_EXISTS");
		require(!borrowableInfo[borrowable].enabled, "LendingVaultV2: BORROWABLE_ENABLED");	
		
		uint underlyingBalance = borrowable.myUnderlyingBalance();
		require(underlyingBalance > 0, "LendingVaultV2: ZERO_AMOUNT");
		
		uint redeemTokens = borrowable.myBalance();
		uint actualRedeemAmount = _deallocate(IBorrowable(borrowable), redeemTokens);	

		emit UnwindBorrowable(address(borrowable), underlyingBalance, actualRedeemAmount);
	}
	
	modifier onlyAdmin() {
		require(msg.sender == ILendingVaultV2Factory(factory).admin(), "LendingVaultV2: UNAUTHORIZED");
		_;
	}
}

// File: contracts\interfaces\ILendingVaultCallee.sol

pragma solidity >=0.5.0;

interface ILendingVaultCallee {
    function lendingVaultAllocate(address borrowable, uint allocateAmount, bytes calldata data) external;
}

// File: contracts\LendingVaultV2.sol

pragma solidity =0.5.16;
contract LendingVaultV2 is LVSetterV2 {

	function _getTotalSupplied() internal returns (uint totalSupplied) {
		for (uint i = 0; i < borrowables.length; i++) {
			address borrowable = borrowables[i];
			totalSupplied = totalSupplied.add(borrowable.myUnderlyingBalance());
		}
	}
	
	function _mintReserves(uint _exchangeRate, uint _totalSupply) internal returns (uint) {
		uint _exchangeRateLast = exchangeRateLast;
		if (_exchangeRate > _exchangeRateLast) {
			uint _exchangeRateNew = _exchangeRate.sub( _exchangeRate.sub(_exchangeRateLast).mul(reserveFactor).div(1e18) );
			uint liquidity = _totalSupply.mul(_exchangeRate).div(_exchangeRateNew).sub(_totalSupply);
			if (liquidity > 0) {
				address reservesManager = ILendingVaultV2Factory(factory).reservesManager();
				_mint(reservesManager, liquidity);
			}
			exchangeRateLast = _exchangeRateNew;
			return _exchangeRateNew;
		}
		else return _exchangeRate;
	}
	
	function exchangeRate() public returns (uint) {
		uint _totalSupply = totalSupply;
		uint _actualBalance = totalBalance.add(_getTotalSupplied());
		if (_totalSupply == 0 || _actualBalance == 0) return initialExchangeRate;
		uint _exchangeRate = _actualBalance.mul(1e18).div(_totalSupply);
		return _mintReserves(_exchangeRate, _totalSupply);
	}
	
	// this low-level function should be called from another contract
	function mint(address minter) external nonReentrant update returns (uint mintTokens) {
		uint balance = underlying.myBalance();
		uint 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, "LendingVaultV2: MINT_AMOUNT_ZERO");
		_mint(minter, mintTokens);
		_withdrawAndReallocate(0);
		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 (uint redeemAmount) {
		uint redeemTokens = balanceOf[address(this)];
		redeemAmount = redeemTokens.mul(exchangeRate()).div(1e18);

		require(redeemAmount > 0, "LendingVaultV2: REDEEM_AMOUNT_ZERO");
		_burn(address(this), redeemTokens);
		_withdrawAndReallocate(redeemAmount);
		underlying.safeTransfer(redeemer, redeemAmount);
		emit Redeem(msg.sender, redeemer, redeemAmount, redeemTokens);		
	}

	function reallocate() external nonReentrant update {
		_withdrawAndReallocate(0);
	}

	function flashAllocate(address borrowable, uint allocateAmount, bytes calldata data) external nonReentrant update {
		require(borrowableInfo[borrowable].exists, "LendingVaultV2: BORROWABLE_DOESNT_EXISTS");
		require(borrowableInfo[borrowable].enabled, "LendingVaultV2: BORROWABLE_DISABLED");
		
		_withdrawAndReallocate(allocateAmount);
		uint exchangeRate = IBorrowable(borrowable).exchangeRate();
		_allocate(IBorrowable(borrowable), allocateAmount, exchangeRate);
		ILendingVaultCallee(msg.sender).lendingVaultAllocate(borrowable, allocateAmount, data);
		_withdrawAndReallocate(0);
		require(IBorrowable(borrowable).totalBalance() > exchangeRate / 1e15, "LendingVaultV2: INCONVENIENT_REALLOCATION");
	}
}

// File: contracts\interfaces\ILVDeployerV2.sol

pragma solidity >=0.5.0;

interface ILVDeployerV2 {
	function deployVault() external returns (address vault);
}

// File: contracts\LVDeployerV2.sol

pragma solidity =0.5.16;
/*
 * This contract is used by the Factory to deploy LendingVaultV2
 * The bytecode would be too long to fit in the Factory
 */
 
contract LVDeployerV2 is ILVDeployerV2 {
	constructor () public {}
	
	function deployVault() external returns (address vault) {
		vault = address(new LendingVaultV2());
	}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrowable","type":"address"}],"name":"AddBorrowable","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrowable","type":"address"},{"indexed":false,"internalType":"uint256","name":"mintAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"mintTokens","type":"uint256"}],"name":"AllocateIntoBorrowable","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":"borrowable","type":"address"},{"indexed":false,"internalType":"uint256","name":"redeemAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"redeemTokens","type":"uint256"}],"name":"DeallocateFromBorrowable","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrowable","type":"address"}],"name":"DisableBorrowable","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrowable","type":"address"}],"name":"EnableBorrowable","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":"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":true,"internalType":"address","name":"borrowable","type":"address"}],"name":"RemoveBorrowable","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"borrowable","type":"address"},{"indexed":false,"internalType":"uint256","name":"underlyingBalance","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"actualRedeemAmount","type":"uint256"}],"name":"UnwindBorrowable","type":"event"},{"constant":true,"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":"address","name":"_underlying","type":"address"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"}],"name":"_initialize","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":"newReserveFactor","type":"uint256"}],"name":"_setReserveFactor","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"borrowable","type":"address"}],"name":"addBorrowable","outputs":[],"payable":false,"stateMutability":"nonpayable","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":true,"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"borrowableInfo","outputs":[{"internalType":"bool","name":"enabled","type":"bool"},{"internalType":"bool","name":"exists","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"borrowables","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":[{"internalType":"address","name":"borrowable","type":"address"}],"name":"disableBorrowable","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"address","name":"borrowable","type":"address"}],"name":"enableBorrowable","outputs":[],"payable":false,"stateMutability":"nonpayable","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":false,"inputs":[{"internalType":"address","name":"borrowable","type":"address"},{"internalType":"uint256","name":"allocateAmount","type":"uint256"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"flashAllocate","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"getBorrowablesLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"internalType":"address","name":"borrowable","type":"address"}],"name":"indexOfBorrowable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","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":false,"inputs":[],"name":"reallocate","outputs":[],"payable":false,"stateMutability":"nonpayable","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":false,"inputs":[{"internalType":"address","name":"borrowable","type":"address"}],"name":"removeBorrowable","outputs":[],"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":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"payable":false,"stateMutability":"view","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"},{"constant":false,"inputs":[{"internalType":"address","name":"borrowable","type":"address"}],"name":"unwindBorrowable","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

46377:3342:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;46377:3342:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6934:18;;;:::i;:::-;;;;;;;;;;;;;;;;8617:132;;;;;;;;;:::i;:::-;;;;;;;;7010:23;;;:::i;:::-;;;;;;;;43444:538;;;;;;;;;:::i;:::-;;8883:299;;;;;;;;;:::i;9859:108::-;;;:::i;6980:26::-;;;:::i;:::-;;;;;;;;44951:358;;;;;;;;;:::i;7150:31::-;;;:::i;47324:350::-;;;:::i;17685:35::-;;;:::i;42835:305::-;;;;;;;;;:::i;14625:130::-;;;:::i;17391:255::-;;;;;;;;;:::i;44585:361::-;;;;;;;;;:::i;17232:56::-;;;;;;;;;:::i;:::-;;;;;;;;;47748:606;;;;;;;;;:::i;14196:25::-;;;:::i;:::-;;;;;;;;7037:41;;;;;;;;;:::i;7185:38::-;;;;;;;;;:::i;17292:96::-;;;:::i;48427:477::-;;;;;;;;;:::i;6956:20::-;;;:::i;48909:86::-;;;:::i;8754:124::-;;;;;;;;;:::i;14251:24::-;;;:::i;17137:28::-;;;;;;;;;:::i;14279:45::-;;;:::i;16452:127::-;;;;;;;;;:::i;17651:28::-;;;:::i;14225:22::-;;;:::i;45314:622::-;;;;;;;;;:::i;42721:49::-;;;:::i;49000:716::-;;;;;;;;;:::i;9971:235::-;;;;;;;;;:::i;7082:61::-;;;;;;;;;:::i;43987:593::-;;;;;;;;;:::i;43146:255::-;;;;;;;;;:::i;16630:47::-;;;:::i;6934:18::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;8617:132::-;8681:4;8692:36;8701:10;8713:7;8722:5;8692:8;:36::i;:::-;-1:-1:-1;8740:4:0;8617:132;;;;;:::o;7010:23::-;;;;:::o;43444:538::-;46013:7;;;;;;;;;;;45990:37;;;:39;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45990:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45990:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;45990:39:0;;;;;;;;;45976:53;;:10;:53;;;45968:94;;;;;;;;;;;;;;;;;;;;;;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;43572:10;;43532:36;;;;;;;;43572:10;;;;;43532:34;;;;;:36;;;;;;;;;;;;;;:34;:36;;;5:2:-1;;;;30:1;27;20:12;5:2;43532:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;43532:36:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;43532:36:0;;;;;;;;;:50;;;43524:97;;;;;;;;;;;;;;43635:26;;;;;;;:14;:26;;;;;:33;;;;;;43634:34;43626:80;;;;;;;;;;;;;;43719:11;:18;42827:2;-1:-1:-1;43711:94:0;;;;;;;;;;;;;;43812:26;;;;;;;:14;:26;;;;;;:40;;43857:41;43812:40;;;;;;43857:41;43848:4;43857:41;;;;;;43903:11;27:10:-1;;23:18;;;45:23;;43903:28:0;;;;;;;;;;;;43943:34;;;43812:26;43943:34;-1:-1:-1;16921:11:0;:18;;;;16935:4;16921:18;;;43444:538::o;8883:299::-;8976:15;;;8961:4;8976:15;;;:9;:15;;;;;;;;8992:10;8976:27;;;;;;;;9012:2;8976:39;8972:159;;9053:72;;;;;;;;;;;;;;;;;;;;:15;;;-1:-1:-1;9053:15:0;;;:9;:15;;;;;9069:10;9053:27;;;;;;;;;;:72;;9085:5;;9053:72;:31;:72;:::i;:::-;9023:15;;;;;;;:9;:15;;;;;;;;9039:10;9023:27;;;;;;;:102;8972:159;9135:26;9145:4;9151:2;9155:5;9135:9;:26::i;:::-;-1:-1:-1;9173:4:0;8883:299;;;;;;:::o;9859:108::-;9901:66;9859:108;:::o;6980:26::-;;;;;;:::o;44951:358::-;46013:7;;;;;;;;;;;45990:37;;;:39;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45990:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45990:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;45990:39:0;;;;;;;;;45976:53;;:10;:53;;;45968:94;;;;;;;;;;;;;;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;45042:26;;;16905:5;45042:26;;;:14;:26;;;;;:33;16891:19;45042:33;;16891:19;45042:33;45034:86;;;;;;;;;;;;;;45134:26;;;;;;;:14;:26;;;;;:34;;;45133:35;45125:82;;;;;;;;;;;;;;45214:26;;;;;;;:14;:26;;;;;;:41;;;;45251:4;45214:41;;;45267:37;;;45214:26;45267:37;-1:-1:-1;16921:11:0;:18;;;;16935:4;16921:18;;;44951:358::o;7150:31::-;;;;:::o;47324:350::-;47395:11;;47364:4;;;47433:37;47450:19;:17;:19::i;:::-;47433:12;;;:37;:16;:37;:::i;:::-;47411:59;-1:-1:-1;47479:17:0;;;:40;;-1:-1:-1;47500:19:0;;47479:40;47475:72;;;14188:4;47521:26;;;;;;47475:72;47552:18;47573:42;47602:12;47573:24;:14;47592:4;47573:24;:18;:24;:::i;:::-;:28;:42;:28;:42;:::i;:::-;47552:63;;47627:42;47641:13;47656:12;47627:13;:42::i;:::-;47620:49;;;;;47324:350;;:::o;17685:35::-;;;;:::o;42835:305::-;42974:7;;;;42960:10;:21;42952:62;;;;;;;;;;;;;;43039:24;43048:5;;43039:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;81:16;;74:27;;;;-1:-1;;43039:24:0;;;;137:4:-1;43039:24:0;;;;;;;;;;;;;;;;;;-1:-1:-1;43055:7:0;;-1:-1:-1;43055:7:0;;;;43039:24;;43055:7;;;;43039:24;1:33:-1;99:1;81:16;;74:27;;;;-1:-1;43039:8:0;;-1:-1:-1;;;43039:24:0:i;:::-;-1:-1:-1;;43068:10:0;:24;;;;;;;;;;;;;;;;-1:-1:-1;;14188:4:0;43097:16;:38;42835:305::o;14625:130::-;14670:7;;:21;:7;:21;14662:63;;;;;;;;;;;;;;14730:7;:20;;;;14740:10;14730:20;;;14625:130::o;17391:255::-;17459:4;;17470:113;17491:11;:18;17487:22;;17470:113;;;17544:10;17526:28;;:11;17538:1;17526:14;;;;;;;;;;;;;;;;;;;;:28;17522:56;;;17570:1;-1:-1:-1;17563:8:0;;17522:56;17511:3;;17470:113;;;-1:-1:-1;17587:54:0;;;;;;;;;;;;17391:255;;;:::o;44585:361::-;46013:7;;;;;;;;;;;45990:37;;;:39;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45990:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45990:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;45990:39:0;;;;;;;;;45976:53;;:10;:53;;;45968:94;;;;;;;;;;;;;;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;44677:26;;;16905:5;44677:26;;;:14;:26;;;;;:33;16891:19;44677:33;;16891:19;44677:33;44669:86;;;;;;;;;;;;;;44768:26;;;;;;;:14;:26;;;;;:34;;;44760:82;;;;;;;;;;;;;;44849:26;;;44886:5;44849:26;;;:14;:26;;;;;;:42;;;;;;44903:38;;;44886:5;44903:38;-1:-1:-1;16921:11:0;:18;;;;16935:4;16921:18;;;44585:361::o;17232:56::-;;;;;;;;;;;;;;;;;;;;;;:::o;47748:606::-;16851:11;;47816:15;;16851:11;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;47853:10;;16905:5;;47853:22;;:10;;:20;:22::i;:::-;47838:37;;47880:15;47898:25;47910:12;;47898:7;:11;;:25;;;;:::i;:::-;47880:43;;47941:40;47966:14;:12;:14::i;:::-;47941:20;:10;47956:4;47941:20;:14;:20;:::i;:40::-;47928:53;;47991:11;;48006:1;47991:16;47988:180;;;48087:33;:10;14320:4;48087:33;:14;:33;:::i;:::-;48074:46;;48126:36;48140:1;14320:4;48126:5;:36::i;:::-;48193:1;48180:10;:14;48172:59;;;;;;;;;;;;;;48236:25;48242:6;48250:10;48236:5;:25::i;:::-;48266;48289:1;48266:22;:25::i;:::-;48318:6;48301:48;;48306:10;48301:48;;;48326:10;48338;48301:48;;;;;;;;;;;;;;;;17019:1;;17025:9;:7;:9::i;:::-;16921:11;:18;;;;16935:4;16921:18;;;47748:606;;-1:-1:-1;47748:606:0:o;14196:25::-;;;;;;:::o;7037:41::-;;;;;;;;;;;;;:::o;7185:38::-;;;;;;;;;;;;;:::o;17292:96::-;17365:11;:18;17292:96;:::o;48427:477::-;16851:11;;48499:17;;16851:11;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;48561:4;16905:5;48543:24;;;:9;:24;;;;;;48587:42;48624:4;48587:32;48604:14;:12;:14::i;:::-;48587:12;;:32;:16;:32;:::i;:42::-;48572:57;;48659:1;48644:12;:16;48636:63;;;;;;;;;;;;;;48704:34;48718:4;48725:12;48704:5;:34::i;:::-;48743:36;48766:12;48743:22;:36::i;:::-;48784:10;;:47;;:10;;48808:8;48818:12;48784:47;:23;:47;:::i;:::-;48860:8;48841:56;;48848:10;48841:56;;;48870:12;48884;48841:56;;;;;;;;;;;;;;;;17019:1;17025:9;:7;:9::i;6956:20::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48909:86;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;48965:25;16905:5;48965:22;:25::i;:::-;17025:9;:7;:9::i;:::-;16921:11;:18;;;;16935:4;16921:18;;;48909:86::o;8754:124::-;8814:4;8825:32;8835:10;8847:2;8851:5;8825:9;:32::i;14251:24::-;;;;:::o;17137:28::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17137:28:0;:::o;14279:45::-;14320:4;14279:45;:::o;16452:127::-;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;16560:12;;16533:10;;16505:69;;16529:2;;16533:40;;16560:12;16533:22;;:10;;:20;:22::i;:::-;:26;:40;:26;:40;:::i;:::-;16505:10;;;;;:69;;:23;:69;:::i;:::-;-1:-1:-1;16921:11:0;:18;;;;16935:4;16921:18;;;16452:127::o;17651:28::-;;;;:::o;14225:22::-;;;;;;:::o;45314:622::-;46013:7;;;;;;;;;;;45990:37;;;:39;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45990:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45990:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;45990:39:0;;;;;;;;;45976:53;;:10;:53;;;45968:94;;;;;;;;;;;;;;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;45412:26;;;16905:5;45412:26;;;:14;:26;;;;;:33;16891:19;45412:33;;16891:19;45412:33;45404:86;;;;;;;;;;;;;;45504:26;;;;;;;:14;:26;;;;;:34;;;45503:35;45495:82;;;;;;;;;;;;;;45587:22;45612:32;:10;:30;;;:32::i;:::-;45587:57;;45677:1;45657:17;:21;45649:61;;;;;;;;;;;;;;45719:17;45739:22;:10;:20;;;:22::i;:::-;45719:42;;45766:23;45792:50;45816:10;45829:12;45792:11;:50::i;:::-;45766:76;;45880:10;45855:76;;;45893:17;45912:18;45855:76;;;;;;;;;;;;;;;;17019:1;;;17025:9;:7;:9::i;42721:49::-;42763:7;42721:49;:::o;49000:716::-;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;49127:26;;;16905:5;49127:26;;;:14;:26;;;;;:33;16891:19;49127:33;;16891:19;49127:33;49119:86;;;;;;;;;;;;;;49218:26;;;;;;;:14;:26;;;;;:34;;;49210:82;;;;;;;;;;;;;;49301:38;49324:14;49301:22;:38::i;:::-;49344:17;49376:10;49364:36;;;:38;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49364:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49364:38:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;49364:38:0;;;;;;;;;49344:58;;49407:64;49429:10;49442:14;49458:12;49407:9;:64::i;:::-;-1:-1:-1;49476:86:0;;;;;49496:10;;49476:52;;:86;;49529:10;;49541:14;;49557:4;;;;49476:86;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49476:86:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49476:86:0;;;;49567:25;49590:1;49567:22;:25::i;:::-;49661:4;49646:12;:19;49617:10;49605:36;;;:38;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49605:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;49605:38:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;49605:38:0;;;;;;;;;:60;49597:114;;;;;;;;;;;;;;17019:1;17025:9;:7;:9::i;:::-;-1:-1:-1;;16921:11:0;:18;;;;16935:4;16921:18;;;-1:-1:-1;;49000:716:0:o;9971:235::-;10091:74;10107:5;10114:7;10123:5;10130:8;10140:1;10143;10146;9901:66;10091:15;:74::i;:::-;10170:31;10179:5;10186:7;10195:5;10170:8;:31::i;:::-;9971:235;;;;;;;:::o;7082:61::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;43987:593::-;46013:7;;;;;;;;;;;45990:37;;;:39;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45990:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45990:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;45990:39:0;;;;;;;;;45976:53;;:10;:53;;;45968:94;;;;;;;;;;;;;;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;44078:26;;;16905:5;44078:26;;;:14;:26;;;;;:33;16891:19;44078:33;;16891:19;44078:33;44070:86;;;;;;;;;;;;;;44170:26;;;;;;;:14;:26;;;;;:34;;;44169:35;44161:82;;;;;;;;;;;;;;44256:32;:10;:30;;;:32::i;:::-;:37;44248:75;;;;;;;;;;;;;;44347:11;:18;:22;;44330:14;44387:29;44405:10;44387:17;:29::i;:::-;44374:42;;44444:11;44456:9;44444:22;;;;;;;;;;;;;;;;;;44423:11;:18;;44444:22;;;;;44435:5;;44423:18;;;;;;;;;;;;;;:43;;;;;;;;;;;;;;;;;;44471:11;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44500:26;;;;;:14;:26;;;;;;;44493:33;;;;;;44538:37;44500:26;;44538:37;;;-1:-1:-1;;16921:11:0;:18;;;;16935:4;16921:18;;;-1:-1:-1;43987:593:0:o;43146:255::-;46013:7;;;;;;;;;;;45990:37;;;:39;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;45990:39:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;45990:39:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;45990:39:0;;;;;;;;;45976:53;;:10;:53;;;45968:94;;;;;;;;;;;;;;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;42763:7;43241:38;;;43233:82;;;;;;;;;;;;;;43320:13;:32;;;43362:34;;;;;;43336:16;;43362:34;;;;;;;;;;-1:-1:-1;16921:11:0;:18;;;;16935:4;16921:18;;;43146:255::o;16630:47::-;16851:11;;;;16843:43;;;;;;;;;;;;;;16891:11;:19;;;;;;17025:9;:7;:9::i;8222:154::-;8297:16;;;;;;;;:9;:16;;;;;;;;:25;;;;;;;;;;;;;;:33;;;8340:31;;;;;8325:5;;8340:31;;;;;;;;;;8222:154;;;:::o;2350:192::-;2436:7;2472:12;2464:6;;;;2456:29;;;;;;;;;;;;;;;-1:-1:-1;;;2508:5:0;;;2350:192::o;8381:231::-;8470:57;;;;;;;;;;;;;;;;;;;;:15;;;-1:-1:-1;8470:15:0;;;:9;:15;;;;;;;;:57;;8490:5;;8470:57;:19;:57;:::i;:::-;8452:15;;;;;;;;:9;:15;;;;;;:75;;;;8548:13;;;;;;;:24;;8566:5;8548:24;:17;:24;:::i;:::-;8532:13;;;;;;;;:9;:13;;;;;;;:40;;;;8582:25;;;;;;;;;;8601:5;;8582:25;;46421:242;46468:18;;46493:166;46514:11;:18;46510:22;;46493:166;;;46545:18;46566:11;46578:1;46566:14;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46602:51:0;46620:32;46566:14;46620:30;:32::i;:::-;46602:13;;:51;:17;:51;:::i;:::-;46586:67;-1:-1:-1;;46534:3:0;;46493:166;;;;46421:242;:::o;1031:181::-;1089:7;1121:5;;;1145:6;;;;1137:46;;;;;;;;;;;;;2785:471;2843:7;3088:6;3084:47;;-1:-1:-1;3118:1:0;3111:8;;3084:47;3155:5;;;3159:1;3155;:5;:1;3179:5;;;;;:10;3171:56;;;;;;;;;;;;;4443:132;4501:7;4528:39;4532:1;4535;4528:39;;;;;;;;;;;;;;;;;:3;:39::i;46669:649::-;46785:16;;46749:4;;46810:33;;;46806:507;;;46851:21;46875:86;46894:65;46954:4;46894:55;46935:13;;46894:36;46912:17;46894:13;:17;;:36;;;;:::i;:::-;:40;:55;:40;:55;:::i;:65::-;46875:13;;:86;:17;:86;:::i;:::-;46851:110;-1:-1:-1;46967:14:0;46984:71;47042:12;46984:53;46851:110;46984:31;47042:12;47001:13;46984:31;:16;:31;:::i;:71::-;46967:88;-1:-1:-1;47065:13:0;;47061:148;;47136:7;;47113:49;;;;;;;;47087:23;;47136:7;;;47113:47;;:49;;;;;;;;;;;;;;47136:7;47113:49;;;5:2:-1;;;;30:1;27;20:12;5:2;47113:49:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;47113:49:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;47113:49:0;;;;;;;;;47087:75;;47169:33;47175:15;47192:9;47169:5;:33::i;:::-;47061:148;;-1:-1:-1;47214:16:0;:35;;;47233:16;-1:-1:-1;47255:23:0;;-1:-1:-1;47255:23:0;46806:507;47300:13;47293:20;;;;;7412:427;7488:12;;;;:4;;:12;;;;;:::i;:::-;-1:-1:-1;7505:16:0;;;;:6;;:16;;;;;:::i;:::-;-1:-1:-1;7636:95:0;;7569:7;;7636:95;;;;;;;;;;;;;;7738:23;;;;;;;;;;7778:10;;;;;;;;;;;;;;;;7619:210;;;;7636:95;;7768:21;;7796:7;;7818:4;;7619:210;;;;;;;22:32:-1;26:21;;;22:32;6:49;;7619:210:0;;;7604:230;;49:4:-1;7604:230:0;;;;7585:16;:249;-1:-1:-1;;;7412:427:0:o;12409:138::-;12493:46;;;;;12466:7;;12493:31;;;;;;:46;;12533:4;;12493:46;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;12493:46:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;12493:46:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;12493:46:0;;;;;;;;1924:137;1982:7;2009:44;2013:1;2016;2009:44;;;;;;;;;;;;;;;;;:3;:44::i;7844:180::-;7911:11;;:22;;7927:5;7911:22;:15;:22;:::i;:::-;7897:11;:36;7954:13;;;;;;;:9;:13;;;;;;:24;;7972:5;7954:24;:17;:24;:::i;:::-;7938:13;;;;;;;:9;:13;;;;;;:40;;;;7988:31;;7938:13;;;7988:31;;;;8013:5;;7988:31;;;;;;;;;;7844:180;;:::o;37057:4125::-;37244:11;:18;37210:53;;;;;;;;;;;;;;;;37156:51;;37210:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;37293:11:0;:18;37156:107;;-1:-1:-1;37268:22:0;37316:323;37336:11;:18;37332:22;;37316:323;;;37372:14;:30;37387:11;37399:1;37387:14;;;;;;;;;;;;;;;;;;;;;;37372:30;;;;;;;;;;;;:38;;;37367:93;;37419:19;;;;;37445:8;;37367:93;37483:11;:18;37465:10;;37478:47;;37507:17;37478:47;:28;:47;:::i;:::-;37465:60;;37559:74;37602:11;37614:1;37602:14;;;;;;;;;;;;;;;;;;;;37627:4;37559:30;:74::i;:::-;37531:14;37550:5;37546:1;:9;37531:25;;;;;;;;;;;;;:102;;;;37316:323;;37356:3;;37316:323;;;-1:-1:-1;37699:10:0;;37675:21;;37699:22;;:10;;:20;:22::i;:::-;37675:46;-1:-1:-1;37730:6:0;37726:189;37746:17;37742:1;:21;37726:189;;;37776:11;37823:33;:14;37838:1;37823:17;;;;;;;;;;;;;;:31;:33::i;:::-;37794:17;;:14;;37809:1;;37794:17;;;;;;;;;;;;;;;37793:63;;;;;-1:-1:-1;37881:28:0;:16;37793:63;37881:28;:20;:28;:::i;:::-;37862:47;-1:-1:-1;;37765:3:0;;37726:189;;;;37938:78;37959:14;37938:78;;;;;;;;;;;;;;;;;:16;;:78;;:20;:78;:::i;:::-;37919:97;-1:-1:-1;38025:22:0;38021:35;;38049:7;;;;;38021:35;38101:6;38096:333;38137:1;38117:17;:21;38113:1;:25;38096:333;;;38156:6;38151:273;38196:1;38192;38172:17;:21;:25;38168:1;:29;38151:273;;;38216:46;38242:14;38257:1;38259;38257:3;38242:19;;;;;;;;;;;;;;38216:14;38231:1;38216:17;;;;;;;;;;;;;;:25;;:46;;;;:::i;:::-;38211:207;;38272:38;;:::i;:::-;38313:14;38328:1;38313:17;;;;;;;;;;;;;;38272:58;;38358:14;38373:1;38375;38373:3;38358:19;;;;;;;;;;;;;;38338:14;38353:1;38338:17;;;;;;;;;;;;;:39;;;;38407:3;38385:14;38400:1;38402;38400:3;38385:19;;;;;;;;;;;;;:25;;;;38211:207;;38199:3;;38151:273;;;-1:-1:-1;38140:3:0;;38096:333;;;-1:-1:-1;38669:17:0;38704:1;38691:837;38711:17;38707:1;:21;38691:837;;;38741:15;38759:14;38774:1;38759:17;;;;;;;;;;;;;;:34;;;38741:52;;38799:20;38822:1;38799:24;;38829:21;38864:1;38853:13;;;;;;;;;;;;;;;;;;;;;;29:2:-1;21:6;17:15;117:4;105:10;97:6;88:34;136:17;;-1:-1;38853:13:0;-1:-1:-1;38829:37:0;-1:-1:-1;38876:15:0;38872:85;;38937:1;38925:13;;38945:5;;;;;38872:85;38967:6;38962:230;38983:1;38979;:5;38962:230;;;39040:10;39002:14;39017:1;39002:17;;;;;;;;;;;;;;:34;;;:48;38998:59;;39052:5;;38998:59;39077:52;39118:10;39077:14;39092:1;39077:17;;;;;;;;;;;;;;:40;;:52;;;;:::i;:::-;39064:7;39072:1;39064:10;;;;;;;;;;;;;:65;;;;;39154:31;39174:7;39182:1;39174:10;;;;;;;;;;;;;;39154:15;:19;;:31;;;;:::i;:::-;39136:49;-1:-1:-1;38986:3:0;;38962:230;;;;39219:16;39201:15;:34;39197:126;;;39303:1;39291:13;;39311:5;;;;;39197:126;39333:6;39328:195;39349:1;39345;:5;39328:195;;;39368:7;39376:1;39368:10;;;;;;;;;;;;;;39382:1;39368:15;39364:29;;;39385:8;;39364:29;39420:38;39447:7;39455:1;39447:10;;;;;;;;;;;;;;39420:14;39435:1;39420:17;;;;;;;;;;;;;;:26;;:38;;;;:::i;:::-;39400:14;39415:1;39400:17;;;;;;;;;;;;;:58;;;;39484:32;39505:7;39513:1;39505:10;;;;;;;;;;;;;;39484:16;:20;;:32;;;;:::i;:::-;39465:51;;39328:195;39352:3;;39328:195;;;-1:-1:-1;;38730:3:0;;;;;-1:-1:-1;38691:837:0;;-1:-1:-1;38691:837:0;;-1:-1:-1;39641:22:0;39701:16;39641:22;39722:123;39743:9;39739:1;:13;39722:123;;;39785:54;39807:31;:14;39822:1;39807:17;;;;;;;;;;;;;;:29;:31::i;39785:54::-;39765:74;-1:-1:-1;39754:3:0;;39722:123;;;-1:-1:-1;39854:6:0;39849:373;39870:9;39866:1;:13;39849:373;;;39892:11;39926:1;39906:17;:21;:135;;40025:16;39906:135;;;39936:81;39999:17;39936:58;39972:21;39936:31;:14;39951:1;39936:17;;;;;;;:81;39892:149;;40060:16;40051:6;:25;40047:56;;;-1:-1:-1;40087:16:0;40047:56;40129:34;40156:6;40129:14;40144:1;40129:17;;;;;;;:34;40109:14;40124:1;40109:17;;;;;;;;;;;;;;;;;:54;40188:28;:16;40209:6;40188:28;:20;:28;:::i;:::-;40169:47;-1:-1:-1;;39881:3:0;;39849:373;;;-1:-1:-1;40247:6:0;40243:348;40263:17;40259:1;:21;40243:348;;;40329:14;40344:1;40329:17;;;;;;;;;;;;;;:36;;;40297:14;40312:1;40297:17;;;;;;;;;;;;;;:29;;;:68;40293:293;;;40374:17;40394:71;40435:14;40450:1;40435:17;;;;;;;;;;;;;;:29;;;40394:14;40409:1;40394:17;;;;;;;;;;;;;;:36;;;:40;;:71;;;;:::i;:::-;40374:91;;40472:107;40496:14;40511:1;40496:17;;;;;;;;;;;;;;:36;;;40534:12;40548:14;40563:1;40548:17;;;;;;;;;;;;;;:30;;;40472:23;:107::i;:::-;;40293:293;;40282:3;;40243:348;;;;40625:89;40652:14;40625:89;;;;;;;;;;;;;;;;;:10;;:22;;:10;;:20;:22::i;:::-;:26;:89;;:26;:89;:::i;:::-;40606:108;-1:-1:-1;40723:6:0;40719:459;40739:17;40735:1;:21;40719:459;;;40805:14;40820:1;40805:17;;;;;;;;;;;;;;:36;;;40773:14;40788:1;40773:17;;;;;;;;;;;;;;:29;;;:68;40769:404;;;40850:15;40868:71;40902:14;40917:1;40902:17;;;;;;;;;;;;;;:36;;;40868:14;40883:1;40868:17;;;;;;;;;;;;;;:29;;;:33;;:71;;;;:::i;:::-;40850:89;;40963:16;40950:10;:29;40946:64;;;-1:-1:-1;40994:16:0;40946:64;41036:32;:16;41057:10;41036:32;:20;:32;:::i;:::-;41017:51;;41075:91;41085:14;41100:1;41085:17;;;;;;;;;;;;;;:36;;;41123:10;41135:14;41150:1;41135:17;;;;;;;;;;;;;;:30;;;41075:9;:91::i;:::-;;40769:404;;40758:3;;40719:459;;;;37057:4125;;;;;;;;:::o;14786:103::-;14834:10;;:22;;:10;;:20;:22::i;:::-;14819:12;:37;;;14866:18;;;;;;;;;;;;;;;;14786:103::o;8029:188::-;8102:15;;;;;;;:9;:15;;;;;;:26;;8122:5;8102:26;:19;:26;:::i;:::-;8084:15;;;;;;;:9;:15;;;;;:44;8147:11;;:22;;8163:5;8147:22;:15;:22;:::i;:::-;8133:11;:36;8179:33;;8202:1;;8179:33;;;;;;;;8206:5;;8179:33;;13057:346;13209:12;13223:17;13244:5;:10;;13278;13290:2;13294:5;13255:45;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;13255:45:0;;;;;;38:4:-1;29:7;25:18;67:10;61:17;96:58;199:8;192:4;186;182:15;179:29;167:10;160:49;0:215;;;13255:45:0;13244:57;;;;;;;;;;;;;;;;;;;;;;;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;;13208:93:0;;;;13320:7;:57;;;;-1:-1:-1;13332:11:0;;:16;;:44;;;13363:4;13352:24;;;;;;;;;;;;;;13312:83;;;;;;;;;;;;;;13057:346;;;;;:::o;27244:172::-;27311:7;27332:79;27350:10;27374;27362:33;;;27404:4;27362:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;27362:48:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;27362:48:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;27362:48:0;;;;;;;;;27332:17;:79::i;36341:190::-;36423:17;36462:64;36474:10;36486:12;36500:10;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;36500:25:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;36500:25:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;36500:25:0;;;;;;;;;36462:11;:64::i;35166:399::-;35264:15;35299:39;35324:13;35299:20;:10;35314:4;35299:20;:14;:20;:::i;:39::-;35286:52;-1:-1:-1;35347:15:0;35343:29;;-1:-1:-1;35371:1:0;35364:8;;35343:29;35377:10;;:56;;:10;;35409;35422;35377:56;:23;:56;:::i;:::-;35451:30;;;;;:15;;;;;;:30;;35475:4;;35451:30;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35451:30:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;35451:30:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;35451:30:0;;;;;;;;;35438:43;;35524:10;35493:67;;;35537:10;35549;35493:67;;;;;;;;;;;;;;;;35166:399;;;;;:::o;9188:564::-;9355:15;9343:8;:27;;9335:57;;;;;;;;;;;;;;9469:16;;9546:13;;;9397:14;9546:13;;;:6;:13;;;;;;;;:15;;;;;;;;9502:70;;9397:14;;9469:16;9502:70;;9513:8;;9523:5;;9530:7;;9539:5;;9546:15;9563:8;;9502:70;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;9502:70:0;;;9492:81;;;;;;9429:150;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;9429:150:0;;;9414:170;;;;;;9397:187;;9589:24;9616:26;9626:6;9634:1;9637;9640;9616:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;-1:-1;;9616:26:0;;;;;;-1:-1:-1;;9655:30:0;;;;;;;:59;;;9709:5;9689:25;;:16;:25;;;9655:59;9647:99;;;;;;;;;;;;;;9188:564;;;;;;;;;;:::o;5063:345::-;5149:7;5251:12;5244:5;5236:28;;;;;;;;;;;;;;;;5275:9;5291:1;5287;:5;;;;;;;5063:345;-1:-1:-1;;;;;5063:345:0:o;29801:1151::-;29896:28;;:::i;:::-;29931:18;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29931:25:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29931:25:0;;;;29961:17;29981:18;:31;;;:33;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;29981:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;29981:33:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;29981:33:0;;;;;;;;;29961:53;;30019:24;30046:18;:30;;;:32;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30046:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30046:32:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;30046:32:0;;;;;;;;;30019:59;;30083:24;30110:18;:28;;;30139:12;30110:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30110:42:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30110:42:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;30110:42:0;;;;;;;;;30083:69;-1:-1:-1;30157:27:0;30187:44;:19;30083:69;30187:44;:23;:44;:::i;:::-;30157:74;;30249:619;;;;;;;;30286:18;30249:619;;;;;;30324:12;30249:619;;;;30356:18;:31;;;:33;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30356:33:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30356:33:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;30356:33:0;;;;;;;;;30249:619;;;;30411:50;30456:4;30411:40;:22;30438:12;30411:40;:26;:40;:::i;:50::-;30249:619;;;;30487:47;30529:4;30487:37;:19;30511:12;30487:37;:23;:37;:::i;:47::-;30249:619;;;;30553:47;30595:4;30553:37;:19;30577:12;30553:37;:23;:37;:::i;:47::-;30249:619;;;;30622:18;:33;;;:35;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30622:35:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30622:35:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;30622:35:0;;;;;;;;;30249:619;;;;30684:18;:38;;;:40;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30684:40:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30684:40:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;30684:40:0;;;;;;;;;30249:619;;;;30745:18;:32;;;:34;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30745:34:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30745:34:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;30745:34:0;;;;;;;;;30249:619;;;;30801:18;:34;;;:36;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;30801:36:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;30801:36:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;30801:36:0;;;;;;;;;30249:619;;;;30861:1;30249:619;;;30236:632;;30903:22;30914:10;30903;:22::i;:::-;30873:27;;;:52;-1:-1:-1;;;;29801:1151:0;;;;:::o;33015:394::-;33091:17;;:::i;:::-;33110:4;33151:10;:23;;;33125;33137:10;33125:11;:23::i;:::-;:49;33121:77;;;-1:-1:-1;33184:10:0;;-1:-1:-1;33196:1:0;33176:22;;33121:77;33203:23;33229:52;33257:10;:23;;;33229;33241:10;33229:11;:23::i;:52::-;33203:78;;33286:11;33300:52;33309:10;:22;;;33333:18;33300:8;:52::i;:::-;33286:66;;33365:30;33376:10;33388:6;33365:10;:30::i;:::-;33357:47;-1:-1:-1;33397:6:0;-1:-1:-1;;33015:394:0;;;;:::o;34739:184::-;34890:28;;;;;34859;;;:59;;34739:184::o;34181:553::-;34277:4;34303:1;34296:4;:8;34288:36;;;;;;;;;;;;;;34345:10;:27;;;34337:4;:35;;34329:80;;;;;;;;;;;;;;34414:26;34443:45;34471:10;34483:4;34443:27;:45::i;:::-;34414:74;;34493:17;34513:60;34551:21;34513:33;34541:4;34513:10;:23;;;:27;;:33;;;;:::i;:60::-;34493:80;;34597:23;34609:10;34597:11;:23::i;:::-;34582:12;:38;34578:99;;;34670:1;34663:8;;;;;;34578:99;34688:41;34705:23;34717:10;34705:11;:23::i;:::-;34688:12;;:41;:16;:41;:::i;:::-;34681:48;34181:553;-1:-1:-1;;;;;34181:553:0:o;32287:251::-;32371:17;;:::i;:::-;32420:22;;;;:34;;32447:6;32420:34;:26;:34;:::i;:::-;32395:22;;;:59;32489:22;32395:10;32489;:22::i;:::-;32459:27;;;:52;-1:-1:-1;32459:27:0;;32287:251;-1:-1:-1;32287:251:0:o;30957:150::-;31031:4;31049:53;31079:10;:22;;;31049:10;:25;;;:29;;:53;;;;:::i;36537:286::-;36651:23;36702:116;36726:10;36739:63;36774:12;36788:13;36739:34;:63::i;:::-;36804:13;36702:11;:116::i;:::-;36681:137;36537:286;-1:-1:-1;;;;36537:286:0:o;26824:227::-;26915:7;26929:20;26964:10;26952:36;;;:38;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;26952:38:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;26952:38:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;26952:38:0;;;;;;;;;26929:61;-1:-1:-1;27002:44:0;27041:4;27002:34;:16;26929:61;27002:34;:20;:34;:::i;35751:587::-;35853:17;35892:41;35928:4;35892:31;:12;35909:13;35892:31;:16;:31;:::i;:41::-;35877:56;-1:-1:-1;35942:17:0;35938:31;;-1:-1:-1;35968:1:0;35961:8;;35938:31;35974:17;35994:10;:23;;;:25;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;35994:25:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;35994:25:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;35994:25:0;;;;;;;;;35974:45;;36043:12;36028;:27;36024:101;;;36078:41;36105:13;36078:22;:12;36095:4;36078:22;:16;:22;:::i;:41::-;36063:56;;36024:101;36129:67;:32;;;36170:10;36183:12;36129:67;:32;:67;:::i;:::-;36216:32;;;;;:17;;;;;;:32;;36242:4;;36216:32;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;36216:32:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;36216:32:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;36216:32:0;;;;;;;;;36201:47;;36293:10;36260:73;;;36306:12;36320;36260:73;;;;;;;;;;;;;;;;35751:587;;;;;;:::o;31589:693::-;31662:9;31678:21;31702:27;31718:10;31702:15;:27::i;:::-;31678:51;;31734:10;31747:62;31778:10;:30;;;31747:26;31768:4;31747:16;:20;;:26;;;;:::i;:62::-;31734:75;;31814:17;31896:10;:30;;;31877:16;:49;31873:324;;;-1:-1:-1;31949:5:0;31873:324;;;31972:16;31991:120;32064:46;32079:10;:30;;;32069:4;32064:14;;:46;;;;:::i;:::-;31991:68;32054:4;31991:52;32012:10;:30;;;31991:16;:20;;:52;;;;:::i;:120::-;31972:139;;32132:59;32186:4;32132:49;32148:32;32178:1;32148:10;:25;;;:29;;:32;;;;:::i;32132:49::-;:53;:59;:53;:59;:::i;:::-;32117:74;;31873:324;;32208:69;32272:4;32208:59;32261:5;32208:48;32251:4;32208:38;32225:20;32234:10;32225:8;:20::i;:::-;32208:12;;:38;:16;:38;:::i;28669:96::-;28721:6;28748:1;28744;:5;:13;;28756:1;28744:13;;;-1:-1:-1;28752:1:0;;28740:17;-1:-1:-1;28669:96:0:o;32543:467::-;32629:17;;:::i;:::-;32653:23;32679:91;32707:10;:23;;;32679:91;;;;;;;;;;;;;;;;;:23;32691:10;32679:11;:23::i;:91::-;32653:117;;32793:18;32783:6;:28;;32775:87;;;;;;;;;;;;;;32892:22;;;;:34;;32919:6;32892:34;:26;:34;:::i;:::-;32867:22;;;:59;32961:22;32867:10;32961;:22::i;:::-;32931:27;;;:52;-1:-1:-1;32931:27:0;;32543:467;-1:-1:-1;;32543:467:0:o;33414:762::-;33515:26;33560:20;33569:10;33560:8;:20::i;:::-;33552:4;:28;33548:624;;33612:118;33725:4;33612:108;33689:10;:30;;;33612:72;33628:50;33673:4;33628:40;33647:20;33656:10;33647:8;:20::i;:::-;33628:14;:4;33637;33628:14;:8;:14;:::i;:50::-;33612:9;:72::i;:118::-;33588:142;;33548:624;;;33757:25;;;;33748:6;;33757:32;;33787:1;33757:32;:29;:32;:::i;:::-;33748:41;;33795:6;33804:71;33870:4;33804:61;33839:10;:25;;;33804:10;:30;;;:34;;:61;;;;:::i;:71::-;33795:80;;33881:6;33890:134;34003:20;34012:10;34003:8;:20::i;:::-;33890:108;33951:46;33966:10;:30;;;33956:4;33951:14;;:46;;;;:::i;:::-;33890:50;33935:4;33890:40;33899:10;:30;;;33890:4;:8;;:40;;;;:::i;:134::-;33881:143;-1:-1:-1;34030:8:0;34041:71;34057:49;34101:4;34057:39;34080:15;34093:1;34057:39;34080:1;33881:143;34080:8;:5;:8;:::i;:15::-;34057:18;34070:4;34057:8;34063:1;;34057:8;:5;:8;:::i;34041:71::-;34030:82;-1:-1:-1;34142:24:0;34164:1;34142:17;34157:1;34142:17;34030:82;34150:1;34142:10;:7;:10;:::i;:24::-;34118:48;33414:762;-1:-1:-1;;;;;;;33414:762:0:o;28250:167::-;28337:17;28368:44;28378:12;28392;28406:5;28368:9;:44::i;31112:236::-;31190:4;31201:17;31221:23;31233:10;31221:11;:23::i;:::-;31201:43;-1:-1:-1;31253:17:0;31249:31;;31279:1;31272:8;;;;;31249:31;31292:51;31330:12;31292:33;31320:4;31292:10;:23;;;:27;;:33;;;;:::i;31353:231::-;31424:4;31442:137;31574:4;31442:127;31528:40;31543:10;:24;;;31533:4;31528:14;;:40;;;;:::i;:::-;31442:76;31513:4;31442:66;31482:10;:25;;;31442:10;:30;;;:39;;:66;;;;:::i;28883:303::-;28928:6;28955:1;28951;:5;28947:232;;;-1:-1:-1;28977:1:0;29010;29006;29002:5;;:9;29026:92;29037:1;29033;:5;29026:92;;;29063:1;29059:5;;29101:1;29096;29092;29088;:5;;;;;;:9;29087:15;;;;;;29083:19;;29026:92;;;28947:232;;;;29139:6;;29135:44;;-1:-1:-1;29166:1:0;28883:303;;;:::o;27466:607::-;27559:17;;27606:40;27633:12;27606:22;:12;27623:4;27606:22;:16;:22;:::i;:40::-;27583:63;-1:-1:-1;27651:21:0;27675:22;27583:63;27695:1;27675:22;:19;:22;:::i;:::-;27651:46;;27710:6;27706:363;;;27724:27;27754:44;27793:4;27754:34;:16;27775:12;27754:34;:20;:34;:::i;:44::-;27724:74;;27837:12;27811:22;:38;;:75;;27871:15;27811:75;;;27852:16;27811:75;27804:82;;;;;;;27706:363;27904:26;27933:43;27971:4;27933:33;:15;27953:12;27933:33;:19;:33;:::i;:43::-;27904:72;;28014:12;27989:21;:37;;:74;;28047:16;27989:74;;;28029:15;27982:81;;;;;;;46377:3342;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;46377:3342:0;;;-1:-1:-1;46377:3342:0;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;5:130:-1;72:20;;97:33;72:20;97:33;;142:134;220:13;;238:33;220:13;238:33;;283:128;358:13;;376:30;358:13;376:30;;418:130;485:20;;510:33;485:20;510:33;;569:336;;;683:3;676:4;668:6;664:17;660:27;650:2;;701:1;698;691:12;650:2;-1:-1;721:20;;761:18;750:30;;747:2;;;793:1;790;783:12;747:2;827:4;819:6;815:17;803:29;;878:3;870:4;862:6;858:17;848:8;844:32;841:41;838:2;;;895:1;892;885:12;838:2;643:262;;;;;;1410:134;1488:13;;1506:33;1488:13;1506:33;;1551:126;1616:20;;1641:31;1616:20;1641:31;;1684:241;;1788:2;1776:9;1767:7;1763:23;1759:32;1756:2;;;1804:1;1801;1794:12;1756:2;1839:1;1856:53;1901:7;1881:9;1856:53;;1932:263;;2047:2;2035:9;2026:7;2022:23;2018:32;2015:2;;;2063:1;2060;2053:12;2015:2;2098:1;2115:64;2171:7;2151:9;2115:64;;2202:366;;;2323:2;2311:9;2302:7;2298:23;2294:32;2291:2;;;2339:1;2336;2329:12;2291:2;2374:1;2391:53;2436:7;2416:9;2391:53;;;2381:63;;2353:97;2481:2;2499:53;2544:7;2535:6;2524:9;2520:22;2499:53;;;2489:63;;2460:98;2285:283;;;;;;2575:491;;;;2713:2;2701:9;2692:7;2688:23;2684:32;2681:2;;;2729:1;2726;2719:12;2681:2;2764:1;2781:53;2826:7;2806:9;2781:53;;;2771:63;;2743:97;2871:2;2889:53;2934:7;2925:6;2914:9;2910:22;2889:53;;;2879:63;;2850:98;2979:2;2997:53;3042:7;3033:6;3022:9;3018:22;2997:53;;;2987:63;;2958:98;2675:391;;;;;;3073:991;;;;;;;;3277:3;3265:9;3256:7;3252:23;3248:33;3245:2;;;3294:1;3291;3284:12;3245:2;3329:1;3346:53;3391:7;3371:9;3346:53;;;3336:63;;3308:97;3436:2;3454:53;3499:7;3490:6;3479:9;3475:22;3454:53;;;3444:63;;3415:98;3544:2;3562:53;3607:7;3598:6;3587:9;3583:22;3562:53;;;3552:63;;3523:98;3652:2;3670:53;3715:7;3706:6;3695:9;3691:22;3670:53;;;3660:63;;3631:98;3760:3;3779:51;3822:7;3813:6;3802:9;3798:22;3779:51;;;3769:61;;3739:97;3867:3;3886:53;3931:7;3922:6;3911:9;3907:22;3886:53;;;3876:63;;3846:99;3976:3;3995:53;4040:7;4031:6;4020:9;4016:22;3995:53;;;3985:63;;3955:99;3239:825;;;;;;;;;;;4071:743;;;;;;4249:2;4237:9;4228:7;4224:23;4220:32;4217:2;;;4265:1;4262;4255:12;4217:2;4300:1;4317:53;4362:7;4342:9;4317:53;;;4307:63;;4279:97;4435:2;4424:9;4420:18;4407:32;4459:18;4451:6;4448:30;4445:2;;;4491:1;4488;4481:12;4445:2;4519:65;4576:7;4567:6;4556:9;4552:22;4519:65;;;4509:75;;;;4386:204;4649:2;4638:9;4634:18;4621:32;4673:18;4665:6;4662:30;4659:2;;;4705:1;4702;4695:12;4659:2;4733:65;4790:7;4781:6;4770:9;4766:22;4733:65;;;4723:75;;;;4600:204;4211:603;;;;;;;;;4821:366;;;4942:2;4930:9;4921:7;4917:23;4913:32;4910:2;;;4958:1;4955;4948:12;4910:2;4993:1;5010:53;5055:7;5035:9;5010:53;;;5000:63;;4972:97;5100:2;5118:53;5163:7;5154:6;5143:9;5139:22;5118:53;;5194:615;;;;;5351:2;5339:9;5330:7;5326:23;5322:32;5319:2;;;5367:1;5364;5357:12;5319:2;5402:1;5419:53;5464:7;5444:9;5419:53;;;5409:63;;5381:97;5509:2;5527:53;5572:7;5563:6;5552:9;5548:22;5527:53;;;5517:63;;5488:98;5645:2;5634:9;5630:18;5617:32;5669:18;5661:6;5658:30;5655:2;;;5701:1;5698;5691:12;5655:2;5729:64;5785:7;5776:6;5765:9;5761:22;5729:64;;;5313:496;;;;-1:-1;5719:74;-1:-1;;;;5313:496;5816:257;;5928:2;5916:9;5907:7;5903:23;5899:32;5896:2;;;5944:1;5941;5934:12;5896:2;5979:1;5996:61;6049:7;6029:9;5996:61;;6080:241;;6184:2;6172:9;6163:7;6159:23;6155:32;6152:2;;;6200:1;6197;6190:12;6152:2;6235:1;6252:53;6297:7;6277:9;6252:53;;6328:263;;6443:2;6431:9;6422:7;6418:23;6414:32;6411:2;;;6459:1;6456;6449:12;6411:2;6494:1;6511:64;6567:7;6547:9;6511:64;;6598:113;6681:24;6699:5;6681:24;;;6676:3;6669:37;6663:48;;;6718:104;6795:21;6810:5;6795:21;;6829:113;6912:24;6930:5;6912:24;;6949:152;7050:45;7070:24;7088:5;7070:24;;;7050:45;;7131:297;;7245:70;7308:6;7303:3;7245:70;;;7238:77;;7327:43;7363:6;7358:3;7351:5;7327:43;;;7392:29;7414:6;7392:29;;;7383:39;;;;7231:197;-1:-1;;;7231:197;7436:356;;7564:38;7596:5;7564:38;;;7614:88;7695:6;7690:3;7614:88;;;7607:95;;7707:52;7752:6;7747:3;7740:4;7733:5;7729:16;7707:52;;;7771:16;;;;;7544:248;-1:-1;;7544:248;7799:347;;7911:39;7944:5;7911:39;;;7962:71;8026:6;8021:3;7962:71;;;7955:78;;8038:52;8083:6;8078:3;8071:4;8064:5;8060:16;8038:52;;;8111:29;8133:6;8111:29;;8500:317;;8660:67;8724:2;8719:3;8660:67;;;8760:19;8740:40;;8808:2;8799:12;;8646:171;-1:-1;;8646:171;8826:329;;8986:67;9050:2;9045:3;8986:67;;;9086:31;9066:52;;9146:2;9137:12;;8972:183;-1:-1;;8972:183;9164:398;;9342:84;9424:1;9419:3;9342:84;;;9459:66;9439:87;;9554:1;9545:11;;9328:234;-1:-1;;9328:234;9571:327;;9731:67;9795:2;9790:3;9731:67;;;9831:29;9811:50;;9889:2;9880:12;;9717:181;-1:-1;;9717:181;9907:370;;10067:67;10131:2;10126:3;10067:67;;;10167:34;10147:55;;10236:3;10231:2;10222:12;;10215:25;10268:2;10259:12;;10053:224;-1:-1;;10053:224;10286:372;;10446:67;10510:2;10505:3;10446:67;;;10546:34;10526:55;;10615:5;10610:2;10601:12;;10594:27;10649:2;10640:12;;10432:226;-1:-1;;10432:226;10667:375;;10827:67;10891:2;10886:3;10827:67;;;10927:34;10907:55;;10996:8;10991:2;10982:12;;10975:30;11033:2;11024:12;;10813:229;-1:-1;;10813:229;11051:371;;11211:67;11275:2;11270:3;11211:67;;;11311:34;11291:55;;11380:4;11375:2;11366:12;;11359:26;11413:2;11404:12;;11197:225;-1:-1;;11197:225;11431:327;;11591:67;11655:2;11650:3;11591:67;;;11691:29;11671:50;;11749:2;11740:12;;11577:181;-1:-1;;11577:181;11767:315;;11927:67;11991:2;11986:3;11927:67;;;12027:17;12007:38;;12073:2;12064:12;;11913:169;-1:-1;;11913:169;12091:331;;12251:67;12315:2;12310:3;12251:67;;;12351:33;12331:54;;12413:2;12404:12;;12237:185;-1:-1;;12237:185;12431:325;;12591:67;12655:2;12650:3;12591:67;;;12691:27;12671:48;;12747:2;12738:12;;12577:179;-1:-1;;12577:179;12765:492;;12943:85;13025:2;13020:3;12943:85;;;13061:34;13041:55;;13130:34;13125:2;13116:12;;13109:56;13199:20;13194:2;13185:12;;13178:42;13248:2;13239:12;;12929:328;-1:-1;;12929:328;13266:370;;13426:67;13490:2;13485:3;13426:67;;;13526:34;13506:55;;13595:3;13590:2;13581:12;;13574:25;13627:2;13618:12;;13412:224;-1:-1;;13412:224;13645:378;;13805:67;13869:2;13864:3;13805:67;;;13905:34;13885:55;;13974:11;13969:2;13960:12;;13953:33;14014:2;14005:12;;13791:232;-1:-1;;13791:232;14032:377;;14192:67;14256:2;14251:3;14192:67;;;14292:34;14272:55;;14361:10;14356:2;14347:12;;14340:32;14400:2;14391:12;;14178:231;-1:-1;;14178:231;14418:313;;14578:67;14642:2;14637:3;14578:67;;;14678:15;14658:36;;14722:2;14713:12;;14564:167;-1:-1;;14564:167;14740:332;;14900:67;14964:2;14959:3;14900:67;;;15000:34;14980:55;;15063:2;15054:12;;14886:186;-1:-1;;14886:186;15081:328;;15241:67;15305:2;15300:3;15241:67;;;15341:30;15321:51;;15400:2;15391:12;;15227:182;-1:-1;;15227:182;15418:371;;15578:67;15642:2;15637:3;15578:67;;;15678:34;15658:55;;15747:4;15742:2;15733:12;;15726:26;15780:2;15771:12;;15564:225;-1:-1;;15564:225;15798:383;;15958:67;16022:2;16017:3;15958:67;;;16058:34;16038:55;;16127:16;16122:2;16113:12;;16106:38;16172:2;16163:12;;15944:237;-1:-1;;15944:237;16190:332;;16350:67;16414:2;16409:3;16350:67;;;16450:34;16430:55;;16513:2;16504:12;;16336:186;-1:-1;;16336:186;16531:371;;16691:67;16755:2;16750:3;16691:67;;;16791:34;16771:55;;16860:4;16855:2;16846:12;;16839:26;16893:2;16884:12;;16677:225;-1:-1;;16677:225;16911:327;;17071:67;17135:2;17130:3;17071:67;;;17171:29;17151:50;;17229:2;17220:12;;17057:181;-1:-1;;17057:181;17247:373;;17407:67;17471:2;17466:3;17407:67;;;17507:34;17487:55;;17576:6;17571:2;17562:12;;17555:28;17611:2;17602:12;;17393:227;-1:-1;;17393:227;17629:319;;17789:67;17853:2;17848:3;17789:67;;;17889:21;17869:42;;17939:2;17930:12;;17775:173;-1:-1;;17775:173;18076:107;18155:22;18171:5;18155:22;;18190:262;;18334:93;18423:3;18414:6;18334:93;;18459:650;;18714:148;18858:3;18714:148;;;18707:155;;18873:75;18944:3;18935:6;18873:75;;;18970:2;18965:3;18961:12;18954:19;;18984:75;19055:3;19046:6;18984:75;;;-1:-1;19081:2;19072:12;;18695:414;-1:-1;;18695:414;19116:372;;19315:148;19459:3;19315:148;;19495:213;19613:2;19598:18;;19627:71;19602:9;19671:6;19627:71;;19715:324;19861:2;19846:18;;19875:71;19850:9;19919:6;19875:71;;;19957:72;20025:2;20014:9;20010:18;20001:6;19957:72;;20046:539;20248:2;20233:18;;20262:71;20237:9;20306:6;20262:71;;;20344:72;20412:2;20401:9;20397:18;20388:6;20344:72;;;20464:9;20458:4;20454:20;20449:2;20438:9;20434:18;20427:48;20489:86;20570:4;20561:6;20553;20489:86;;;20481:94;20219:366;-1:-1;;;;;;20219:366;20592:201;20704:2;20689:18;;20718:65;20693:9;20756:6;20718:65;;20800:300;20934:2;20919:18;;20948:65;20923:9;20986:6;20948:65;;;21024:66;21086:2;21075:9;21071:18;21062:6;21024:66;;21107:213;21225:2;21210:18;;21239:71;21214:9;21283:6;21239:71;;21327:771;21585:3;21570:19;;21600:71;21574:9;21644:6;21600:71;;;21682:72;21750:2;21739:9;21735:18;21726:6;21682:72;;;21765;21833:2;21822:9;21818:18;21809:6;21765:72;;;21848;21916:2;21905:9;21901:18;21892:6;21848:72;;;21931:73;21999:3;21988:9;21984:19;21975:6;21931:73;;;22015;22083:3;22072:9;22068:19;22059:6;22015:73;;22105:659;22335:3;22320:19;;22350:71;22324:9;22394:6;22350:71;;;22432:72;22500:2;22489:9;22485:18;22476:6;22432:72;;;22515;22583:2;22572:9;22568:18;22559:6;22515:72;;;22598;22666:2;22655:9;22651:18;22642:6;22598:72;;;22681:73;22749:3;22738:9;22734:19;22725:6;22681:73;;22771:539;22969:3;22954:19;;22984:71;22958:9;23028:6;22984:71;;;23066:68;23130:2;23119:9;23115:18;23106:6;23066:68;;;23145:72;23213:2;23202:9;23198:18;23189:6;23145:72;;;23228;23296:2;23285:9;23281:18;23272:6;23228:72;;23317:293;23451:2;23465:47;;;23436:18;;23526:74;23436:18;23586:6;23526:74;;23925:407;24116:2;24130:47;;;24101:18;;24191:131;24101:18;24191:131;;24339:407;24530:2;24544:47;;;24515:18;;24605:131;24515:18;24605:131;;24753:407;24944:2;24958:47;;;24929:18;;25019:131;24929:18;25019:131;;25167:407;25358:2;25372:47;;;25343:18;;25433:131;25343:18;25433:131;;25581:407;25772:2;25786:47;;;25757:18;;25847:131;25757:18;25847:131;;25995:407;26186:2;26200:47;;;26171:18;;26261:131;26171:18;26261:131;;26409:407;26600:2;26614:47;;;26585:18;;26675:131;26585:18;26675:131;;26823:407;27014:2;27028:47;;;26999:18;;27089:131;26999:18;27089:131;;27237:407;27428:2;27442:47;;;27413:18;;27503:131;27413:18;27503:131;;27651:407;27842:2;27856:47;;;27827:18;;27917:131;27827:18;27917:131;;28065:407;28256:2;28270:47;;;28241:18;;28331:131;28241:18;28331:131;;28479:407;28670:2;28684:47;;;28655:18;;28745:131;28655:18;28745:131;;28893:407;29084:2;29098:47;;;29069:18;;29159:131;29069:18;29159:131;;29307:407;29498:2;29512:47;;;29483:18;;29573:131;29483:18;29573:131;;29721:407;29912:2;29926:47;;;29897:18;;29987:131;29897:18;29987:131;;30135:407;30326:2;30340:47;;;30311:18;;30401:131;30311:18;30401:131;;30549:407;30740:2;30754:47;;;30725:18;;30815:131;30725:18;30815:131;;30963:407;31154:2;31168:47;;;31139:18;;31229:131;31139:18;31229:131;;31377:407;31568:2;31582:47;;;31553:18;;31643:131;31553:18;31643:131;;31791:407;31982:2;31996:47;;;31967:18;;32057:131;31967:18;32057:131;;32205:407;32396:2;32410:47;;;32381:18;;32471:131;32381:18;32471:131;;32619:407;32810:2;32824:47;;;32795:18;;32885:131;32795:18;32885:131;;33033:407;33224:2;33238:47;;;33209:18;;33299:131;33209:18;33299:131;;33447:407;33638:2;33652:47;;;33623:18;;33713:131;33623:18;33713:131;;34081:324;34227:2;34212:18;;34241:71;34216:9;34285:6;34241:71;;34412:205;34526:2;34511:18;;34540:67;34515:9;34580:6;34540:67;;34624:121;34711:12;;34682:63;35007:162;35109:19;;;35158:4;35149:14;;35102:67;35656:91;;35718:24;35736:5;35718:24;;35754:85;35820:13;35813:21;;35796:43;35925:121;35998:42;35987:54;;35970:76;36132:81;36203:4;36192:16;;36175:38;36221:145;36302:6;36297:3;36292;36279:30;-1:-1;36358:1;36340:16;;36333:27;36272:94;36375:268;36440:1;36447:101;36461:6;36458:1;36455:13;36447:101;;;36528:11;;;36522:18;36509:11;;;36502:39;36483:2;36476:10;36447:101;;;36563:6;36560:1;36557:13;36554:2;;;36628:1;36619:6;36614:3;36610:16;36603:27;36554:2;36424:219;;;;;36732:97;36820:2;36800:14;36816:7;36796:28;;36780:49;36837:117;36906:24;36924:5;36906:24;;;36899:5;36896:35;36886:2;;36945:1;36942;36935:12;36961:111;37027:21;37042:5;37027:21;;37079:117;37148:24;37166:5;37148:24;;37327:113;37394:22;37410:5;37394:22;

bzzr://7ada0592708aa01fbd945b6f4ba305364f7fa224da0db3fbb0ea3688c275c492